diff --git a/engine/CharacterConversionEngine/ContainerCharacterConversionEngine.cpp b/engine/CharacterConversionEngine/ContainerCharacterConversionEngine.cpp
index f4c218e..98be92a 100644
--- a/engine/CharacterConversionEngine/ContainerCharacterConversionEngine.cpp
+++ b/engine/CharacterConversionEngine/ContainerCharacterConversionEngine.cpp
@@ -1 +1 @@
-#include "ContainerCharacterConversionEngine.h"


using namespace ai_matrix;

namespace
{
    //按照x坐标排列
    bool CompareX(const SingleData &v1, const SingleData &v2)
    {
        return (v1.fLTX < v2.fLTX);
    }
    //按照y坐标排列
    bool CompareY(const SingleData &v1, const SingleData &v2)
    {
        return (v1.fLTY < v2.fLTY);
    }
}

ContainerCharacterConversionEngine::ContainerCharacterConversionEngine() {}

ContainerCharacterConversionEngine::~ContainerCharacterConversionEngine() {}

APP_ERROR ContainerCharacterConversionEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort3_ = engineName_ + "_" + std::to_string(engineId_) + "_3";
    this->modelConfig_ = Config::getins()->getModelByContainerStep2Config();
    this->baseConfig_ = Config::getins()->getBaseConfig();

    LogInfo << "ContainerCharacterConversionEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerCharacterConversionEngine::DeInit()
{
    LogInfo << "ContainerCharacterConversionEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 验证集装箱号是否满足规则(前10位依次与2^0 ~2^9相乘）/11 所得余数，即是校验位)
* inParam : std::string &strContainerNo   集装箱号信息
* outParam: N/A
* return  : true(校验通过)/false(校验失败)
*/
bool ContainerCharacterConversionEngine::verifyContainerNo(std::string &strContainerNo)
{
    bool bChkFlag = false;

    if(strContainerNo.length() != 11)
    {
        return bChkFlag;
    }

    int iSum = 0;
    for (int i = 0; i < strContainerNo.length()-1; ++i)
    {
        iSum += this->mapExchange_[strContainerNo.substr(i, 1)] * int(pow(2.0, i));
    }

    //当校验位等于10时要继续模运算,iSum % 11 % 10,保证最终结果为0~9之间的数
    int iChkValue = iSum % 11 % 10;
    if (iChkValue == atoi(strContainerNo.substr(strContainerNo.length()-1, 1).c_str()))
    {
        bChkFlag = true;
    }
    return bChkFlag;
}

void ContainerCharacterConversionEngine::transContainerType(Step2ResultData &step2ResultData, std::map<int, std::vector<SingleData>> &mapLine)
{
    TransInfo info;
    info.iLine = 1;
    //集装箱型号（4位 字母或数字）
    if (mapLine.find(3) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(3).size(); j++)
        {
            strTemp += vecClassNames_.at(mapLine.at(3).at(j).iClassId);
        }
        int nTypesize = strTemp.length();
        nTypesize = nTypesize > 4 ? 4 : nTypesize;
        info.strTmpResult = strTemp.substr(0, nTypesize);
    }
    if (info.strTmpResult.length() != 4)
    {
        info.bIsChkFlag = false;
    }
//    step2ResultData.transInfo = info;
}

/**
* 集装箱框内容转换
* inParam : std::map<int, std::vector<SingleData>> &mapLine
* outParam: TransSubData &transSubData
* return  : N/A
*/
void ContainerCharacterConversionEngine::transContainerNum(Step2ResultData &step2ResultData, std::map<int, std::vector<SingleData>> &mapLine)
{
    TransInfo info;
    info.iLine = 0;
    // 箱主代码+设备识别码（4位英文字母）
    if (mapLine.find(0) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(0).size(); j++)
        {
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(0).at(j).iClassId);
            // 过滤非字母
            if (strOne[0] < 'A' || strOne[0] > 'Z')
            {
//                LogDebug << strOne << " not A-Z in container";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(0).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(0).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    // 箱号（6位数字）
    if (mapLine.find(1) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(1).size(); j++)
        {
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(1).at(j).iClassId);
            // 过滤非数字
            if (strOne[0] < '0' || strOne[0] > '9')
            {
//                LogDebug << "engineId:" << engineId_ << " " << strOne << " not digit in num";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(1).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(1).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    //校验码（1位数字）
    if (mapLine.find(2) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(2).size(); j++)
        {
            //过滤非数字
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(2).at(j).iClassId);
            if (strOne[0] < '0' || strOne[0] > '9')
            {
//                LogDebug << "engineId:" << engineId_ << " " << strOne << " not digit in container_2";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(2).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(2).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    if (this->verifyContainerNo(info.strTmpResult))
    {
        info.bIsChkFlag = true;
    }

    step2ResultData.transInfo = info;
}

APP_ERROR ContainerCharacterConversionEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        std::shared_ptr<void> pVoidData0 = nullptr;
        inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000); //1ms
            continue;
        }

        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::static_pointer_cast<VStep2OutputData>(pVoidData0);
        if (pVStep2OutputData->bIsEnd)
        {
            LogInfo << "---- 数据源:" << pVStep2OutputData->iDataSource;
            outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(pVStep2OutputData->iDataSource)]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
            outputQueMap_[strPort3_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
        }

        std::vector<SingleData> vecSingleData = pVStep2OutputData->step2ResultData.vecSingleData;

        if (pVStep2OutputData->step2ResultData.fScore == 0.0f) continue;

        std::map<int, std::vector<SingleData>> mapLine;
        for (auto & it_singleData : vecSingleData)
        {
            mapLine[it_singleData.iLine].push_back(it_singleData);
        }

        bool bSortByX =
                (pVStep2OutputData->step2ResultData.fRBY - pVStep2OutputData->step2ResultData.fLTY) <
                ((pVStep2OutputData->step2ResultData.fRBX - pVStep2OutputData->step2ResultData.fLTX) *
                 1.5);

        //每一行按x坐标排序
        for (auto & it : mapLine)
        {
            if (it.second.size() > 2)
            {
                std::set<float> setX;
                std::set<float> setY;
                for (auto & it_singleData : it.second)
                {
                    setX.insert(it_singleData.fLTX);
                    setY.insert(it_singleData.fLTY);
                }
                float X = *setX.rbegin() - *setX.begin();
                float Y = *setY.rbegin() - *setY.begin();
                bSortByX = (X > Y);
            }

            if (bSortByX)
            {
                std::sort(it.second.begin(), it.second.end(), CompareX);
            }
            else
            {
                std::sort(it.second.begin(), it.second.end(), CompareY);
            }

            std::string strTemp;
            for (auto & it_singleData : it.second)
            {
                strTemp += this->modelConfig_.vecClass.at(it_singleData.iClassId);
            }
        }

        switch (pVStep2OutputData->step2ResultData.iClassId)
        {
            case 0:
                this->transContainerNum(pVStep2OutputData->step2ResultData, mapLine);
//                    this->transContainerType(it_step2ResultData, mapLine);
                break;
            default:
                break;
        }

        outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(pVStep2OutputData->iDataSource)]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
        outputQueMap_[strPort3_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
    }

    return APP_ERR_OK;
}
\ No newline at end of file
+#include "ContainerCharacterConversionEngine.h"


using namespace ai_matrix;

namespace
{
    //按照x坐标排列
    bool CompareX(const SingleData &v1, const SingleData &v2)
    {
        return (v1.fLTX < v2.fLTX);
    }
    //按照y坐标排列
    bool CompareY(const SingleData &v1, const SingleData &v2)
    {
        return (v1.fLTY < v2.fLTY);
    }
}

ContainerCharacterConversionEngine::ContainerCharacterConversionEngine() {}

ContainerCharacterConversionEngine::~ContainerCharacterConversionEngine() {}

APP_ERROR ContainerCharacterConversionEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort3_ = engineName_ + "_" + std::to_string(engineId_) + "_3";
    this->modelConfig_ = Config::getins()->getModelByContainerStep2Config();
    this->baseConfig_ = Config::getins()->getBaseConfig();

    LogInfo << "ContainerCharacterConversionEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerCharacterConversionEngine::DeInit()
{
    LogInfo << "ContainerCharacterConversionEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 验证集装箱号是否满足规则(前10位依次与2^0 ~2^9相乘）/11 所得余数，即是校验位)
* inParam : std::string &strContainerNo   集装箱号信息
* outParam: N/A
* return  : true(校验通过)/false(校验失败)
*/
bool ContainerCharacterConversionEngine::verifyContainerNo(std::string &strContainerNo)
{
    bool bChkFlag = false;

    if(strContainerNo.length() != 11)
    {
        return bChkFlag;
    }

    int iSum = 0;
    for (int i = 0; i < strContainerNo.length()-1; ++i)
    {
        iSum += this->mapExchange_[strContainerNo.substr(i, 1)] * int(pow(2.0, i));
    }

    //当校验位等于10时要继续模运算,iSum % 11 % 10,保证最终结果为0~9之间的数
    int iChkValue = iSum % 11 % 10;
    if (iChkValue == atoi(strContainerNo.substr(strContainerNo.length()-1, 1).c_str()))
    {
        bChkFlag = true;
    }
    return bChkFlag;
}

void ContainerCharacterConversionEngine::transContainerType(Step2ResultData &step2ResultData, std::map<int, std::vector<SingleData>> &mapLine)
{
    TransInfo info;
    info.iLine = 1;
    //集装箱型号（4位 字母或数字）
    if (mapLine.find(3) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(3).size(); j++)
        {
            strTemp += vecClassNames_.at(mapLine.at(3).at(j).iClassId);
        }
        int nTypesize = strTemp.length();
        nTypesize = nTypesize > 4 ? 4 : nTypesize;
        info.strTmpResult = strTemp.substr(0, nTypesize);
    }
    if (info.strTmpResult.length() != 4)
    {
        info.bIsChkFlag = false;
    }
//    step2ResultData.transInfo = info;
}

/**
* 集装箱框内容转换
* inParam : std::map<int, std::vector<SingleData>> &mapLine
* outParam: TransSubData &transSubData
* return  : N/A
*/
void ContainerCharacterConversionEngine::transContainerNum(Step2ResultData &step2ResultData, std::map<int, std::vector<SingleData>> &mapLine)
{
    TransInfo info;
    info.iLine = 0;
    // 箱主代码+设备识别码（4位英文字母）
    if (mapLine.find(0) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(0).size(); j++)
        {
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(0).at(j).iClassId);
            // 过滤非字母
            if (strOne[0] < 'A' || strOne[0] > 'Z')
            {
//                LogDebug << strOne << " not A-Z in container";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(0).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(0).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    // 箱号（6位数字）
    if (mapLine.find(1) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(1).size(); j++)
        {
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(1).at(j).iClassId);
            // 过滤非数字
            if (strOne[0] < '0' || strOne[0] > '9')
            {
//                LogDebug << "engineId:" << engineId_ << " " << strOne << " not digit in num";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(1).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(1).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    //校验码（1位数字）
    if (mapLine.find(2) != mapLine.end())
    {
        std::string strTemp;
        for (auto j = 0; j < mapLine.at(2).size(); j++)
        {
            //过滤非数字
            std::string strOne = this->modelConfig_.vecClass.at(mapLine.at(2).at(j).iClassId);
            if (strOne[0] < '0' || strOne[0] > '9')
            {
//                LogDebug << "engineId:" << engineId_ << " " << strOne << " not digit in container_2";
                continue;
            }
            strTemp += strOne;
            info.vecValue.emplace_back(strOne);
            info.vecScore.emplace_back(mapLine.at(2).at(j).fScore);
            step2ResultData.fSubScoreSum += mapLine.at(2).at(j).fScore;
        }
        info.strTmpResult += strTemp;
    }

    if (this->verifyContainerNo(info.strTmpResult))
    {
        info.bIsChkFlag = true;
    }
    else
    {
        info.strTmpResult = "invalid-" + info.strTmpResult;
    }

    step2ResultData.transInfo = info;
}

APP_ERROR ContainerCharacterConversionEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        std::shared_ptr<void> pVoidData0 = nullptr;
        inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000); //1ms
            continue;
        }

        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::static_pointer_cast<VStep2OutputData>(pVoidData0);
        if (pVStep2OutputData->bIsEnd)
        {
            outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(pVStep2OutputData->iDataSource)]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
            outputQueMap_[strPort3_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
        }

        std::vector<SingleData> vecSingleData = pVStep2OutputData->step2ResultData.vecSingleData;

        if (pVStep2OutputData->step2ResultData.fScore == 0.0f) continue;

        std::map<int, std::vector<SingleData>> mapLine;
        for (auto & it_singleData : vecSingleData)
        {
            mapLine[it_singleData.iLine].push_back(it_singleData);
        }

        bool bSortByX =
                (pVStep2OutputData->step2ResultData.fRBY - pVStep2OutputData->step2ResultData.fLTY) <
                ((pVStep2OutputData->step2ResultData.fRBX - pVStep2OutputData->step2ResultData.fLTX) *
                 1.5);

        //每一行按x坐标排序
        for (auto & it : mapLine)
        {
            if (it.second.size() > 2)
            {
                std::set<float> setX;
                std::set<float> setY;
                for (auto & it_singleData : it.second)
                {
                    setX.insert(it_singleData.fLTX);
                    setY.insert(it_singleData.fLTY);
                }
                float X = *setX.rbegin() - *setX.begin();
                float Y = *setY.rbegin() - *setY.begin();
                bSortByX = (X > Y);
            }

            if (bSortByX)
            {
                std::sort(it.second.begin(), it.second.end(), CompareX);
            }
            else
            {
                std::sort(it.second.begin(), it.second.end(), CompareY);
            }

//            std::string strTemp;
//            for (auto & it_singleData : it.second)
//            {
//                strTemp += this->modelConfig_.vecClass.at(it_singleData.iClassId);
//            }
        }

        switch (pVStep2OutputData->step2ResultData.iClassId)
        {
            case 0:
                this->transContainerNum(pVStep2OutputData->step2ResultData, mapLine);
                break;
            default:
                break;
        }

        // 模型识别不稳定时才用。
//        if (bSortByX && pVStep2OutputData->step2ResultData.transInfo.bIsChkFlag)
//        {
//            if (mapLine.find(0) != mapLine.end() && mapLine.find(1) != mapLine.end())
//            {
//                if (mapLine.at(1).at(0).fLTX < mapLine.at(0).at(0).fLTX)
//                {
//                    pVStep2OutputData->step2ResultData.transInfo.strTmpResult = "invalid-" + pVStep2OutputData->step2ResultData.transInfo.strTmpResult;
//                    pVStep2OutputData->step2ResultData.transInfo.bIsChkFlag = false;
//                }
//            }
//        }

        outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(pVStep2OutputData->iDataSource)]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
        outputQueMap_[strPort3_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
    }

    return APP_ERR_OK;
}
\ No newline at end of file
diff --git a/engine/ControlEngine/ControlEngine.cpp b/engine/ControlEngine/ControlEngine.cpp
index 1501e4f..a5d07d5 100644
--- a/engine/ControlEngine/ControlEngine.cpp
+++ b/engine/ControlEngine/ControlEngine.cpp
@@ -56,6 +56,8 @@ void ControlEngine::endIdentify(int iDataSource)
     std::shared_ptr<VDetectInfo> pVDetectInfo = std::make_shared<VDetectInfo>();
     pVDetectInfo->bIsEnd = true;
     pVDetectInfo->iDataSource = iDataSource;
+    pVDetectInfo->strDetectDate = this->strDetectDate_;
+    pVDetectInfo->strDetectTime = this->strDetectTime_;
     // 传给推理引擎
     outputQueMap_[strPort1_]->push(std::static_pointer_cast<void>(pVDetectInfo), true);
     outputQueMap_[strPort2_]->push(std::static_pointer_cast<void>(pVDetectInfo), true);
diff --git a/engine/CornerInferenceEngine/CornerInferenceEngine.cpp b/engine/CornerInferenceEngine/CornerInferenceEngine.cpp
index 15ceb45..339f6a8 100644
--- a/engine/CornerInferenceEngine/CornerInferenceEngine.cpp
+++ b/engine/CornerInferenceEngine/CornerInferenceEngine.cpp
@@ -106,6 +106,8 @@ APP_ERROR CornerInferenceEngine::Process()
         std::shared_ptr<InferenceResultData> pInferenceResultData = std::make_shared<InferenceResultData>();
         pInferenceResultData->iDataSource = pVDetectInfo->iDataSource;
         pInferenceResultData->bIsEnd = pVDetectInfo->bIsEnd;
+        pInferenceResultData->strDetectDate = pVDetectInfo->strDetectDate;
+        pInferenceResultData->strDetectTime = pVDetectInfo->strDetectTime;
         if (pVDetectInfo->bIsEnd)
         {
             outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pInferenceResultData), true);
diff --git a/engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.cpp b/engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.cpp
index 0da3fcf..95a61d2 100644
--- a/engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.cpp
+++ b/engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.cpp
@@ -1 +1 @@
-#include "DeleteExpiredFolderEngine.h"

using namespace ai_matrix;

DeleteExpiredFolderEngine::DeleteExpiredFolderEngine() {}

DeleteExpiredFolderEngine::~DeleteExpiredFolderEngine() {}

APP_ERROR DeleteExpiredFolderEngine::Init()
{
    this->baseConfig_ = Config::getins()->getBaseConfig();
    LogInfo << "DeleteExpiredFolderEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR DeleteExpiredFolderEngine::DeInit()
{
    LogInfo << "DeleteExpiredFolderEngine DeInit ok";
    return APP_ERR_OK;
}

APP_ERROR DeleteExpiredFolderEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        std::string strTrainDate_temp = TimeUtil::getins()->getDate();

        deletePreviousFolder(this->baseConfig_.strDebugResultPath, strTrainDate_temp, this->baseConfig_.iResultSaveDays);
        deletePreviousFolder(this->baseConfig_.strResultPath, strTrainDate_temp, this->baseConfig_.iResultSaveDays);

        usleep(1000*1000*10); //每10秒执行一次
    }

    return APP_ERR_OK;
}

void DeleteExpiredFolderEngine::deletePreviousFolder(std::string path, const std::string &date, int n_days)
{
    // 1 computer date
    std::string previous_date = getDateBeforeNDays(date, n_days);
    if (!previous_date.empty())
        LogDebug << "Date before " << n_days << " days from " << date << " is: " << previous_date;


    // 2
    std::vector<Date> subfolders;
    getSubfolderNames(path, subfolders);
    // for (const auto &it : subfolders)
    //     std::cout << it.year << "." << it.month << "." << it.day << std::endl;

    // 3 delete
    if (path.back() != '/')
        path += "/";
    Date reference_date = strToDate(previous_date); // 给定的参考日期
    deleteEarlierDatesFolder(path, subfolders, reference_date);
}

// 获取某月有多少天
int DeleteExpiredFolderEngine::daysInMonth(int year, int month)
{
    int max_days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
    {
        max_days[2] = 29; // 闰年2月有29天
    }
    return max_days[month];
}

// 解析字符串为日期结构体
Date DeleteExpiredFolderEngine::strToDate(const std::string &date_str)
{
    std::istringstream iss(date_str);
    int year, month, day;
    char dash;

    if (!(iss >> year >> dash && dash == '-' &&
          iss >> month >> dash && dash == '-' &&
          iss >> day))
    {
        LogError << ("Invalid date format") << ":" << date_str;
    }
    return {year, month, day};
}

// 减去指定天数
void DeleteExpiredFolderEngine::subtractDays(Date &date, int n_days)
{
    while (n_days > 0)
    {
        date.day--;
        n_days--;
        if (date.day == 0)
        {
            if (--date.month == 0)
            {
                --date.year;
                date.month = 12;
            }
            int max_days = daysInMonth(date.year, date.month);
            date.day = max_days;
        }
    }
}

// 格式化日期结构体为字符串
std::string DeleteExpiredFolderEngine::dateToStr(const Date &date)
{
    std::ostringstream oss;
    oss << date.year << "-" << std::setfill('0') << std::setw(2) << date.month << "-" << std::setw(2) << date.day;
    return oss.str();
}

// 主要功能函数，接收一个日期字符串和一个整数n，返回n天前的日期字符串
std::string DeleteExpiredFolderEngine::getDateBeforeNDays(const std::string &input_date, int n_days)
{
    try
    {
        Date date = strToDate(input_date);
        subtractDays(date, n_days);
        return dateToStr(date);
    }
    catch (const std::exception &e)
    {
        LogError << "Error: " << e.what();
        return "";
    }
}

void DeleteExpiredFolderEngine::getSubfolderNames(std::string &directory, std::vector<Date> &folder_names)
{
    if (directory.back() != '/')
        directory += "/";
    DIR *dir;
    struct dirent *ent;
    if ((dir = opendir(directory.c_str())) != nullptr)
    {
        while ((ent = readdir(dir)) != nullptr)
        {
            // 排除"."和".."
            if (ent->d_type == DT_DIR && ent->d_name[0] != '.' && ent->d_name != "best")
            {
                folder_names.push_back(strToDate(ent->d_name));
            }
        }
        closedir(dir);
    }
    else
    {
        LogError << "Unable to open directory: " << directory;
    }
}

void DeleteExpiredFolderEngine::deleteFolder(const std::string directory)
{
    std::string command = "rm -rf " + directory;
    int result = system(command.c_str());

    if (result != 0)
        std::cout << "Failed to remove directory recursively: " << directory << std::endl;
    else
        std::cout << "delete folder successfully : " << directory << std::endl;
}

// 删除向量中小于指定日期的所有元素
void DeleteExpiredFolderEngine::deleteEarlierDatesFolder(std::string &path, std::vector<Date> &subfolders, const Date &reference_date)
{
    if (path.back() != '/')
        path += "/";
    for (const Date &cur : subfolders)
    {
        // bool flag = false;
        if (cur.year < reference_date.year)
        {
            deleteFolder(path + dateToStr(cur));
        }
        else if (cur.year == reference_date.year && cur.month < reference_date.month)
        {
            deleteFolder(path + dateToStr(cur));
        }
        else if (cur.year == reference_date.year && cur.month == reference_date.month && cur.day < reference_date.day)
        {
            deleteFolder(path + dateToStr(cur));
        }
    }
}
\ No newline at end of file
+#include "DeleteExpiredFolderEngine.h"

using namespace ai_matrix;

DeleteExpiredFolderEngine::DeleteExpiredFolderEngine() {}

DeleteExpiredFolderEngine::~DeleteExpiredFolderEngine() {}

APP_ERROR DeleteExpiredFolderEngine::Init()
{
    this->baseConfig_ = Config::getins()->getBaseConfig();
    LogInfo << "DeleteExpiredFolderEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR DeleteExpiredFolderEngine::DeInit()
{
    LogInfo << "DeleteExpiredFolderEngine DeInit ok";
    return APP_ERR_OK;
}

APP_ERROR DeleteExpiredFolderEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        std::string strTrainDate_temp = TimeUtil::getins()->getDate();

        deletePreviousFolder(this->baseConfig_.strDebugResultPath, strTrainDate_temp, this->baseConfig_.iResultSaveDays);
        deletePreviousFolder(this->baseConfig_.strResultPath, strTrainDate_temp, this->baseConfig_.iResultSaveDays + 10);

        usleep(1000*1000*10); //每10秒执行一次
    }

    return APP_ERR_OK;
}

void DeleteExpiredFolderEngine::deletePreviousFolder(std::string path, const std::string &date, int n_days)
{
    // 1 computer date
    std::string previous_date = getDateBeforeNDays(date, n_days);
    if (!previous_date.empty())
        LogDebug << "Date before " << n_days << " days from " << date << " is: " << previous_date;


    // 2
    std::vector<Date> subfolders;
    getSubfolderNames(path, subfolders);
    // for (const auto &it : subfolders)
    //     std::cout << it.year << "." << it.month << "." << it.day << std::endl;

    // 3 delete
    if (path.back() != '/')
        path += "/";
    Date reference_date = strToDate(previous_date); // 给定的参考日期
    deleteEarlierDatesFolder(path, subfolders, reference_date);
}

// 获取某月有多少天
int DeleteExpiredFolderEngine::daysInMonth(int year, int month)
{
    int max_days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
    {
        max_days[2] = 29; // 闰年2月有29天
    }
    return max_days[month];
}

// 解析字符串为日期结构体
Date DeleteExpiredFolderEngine::strToDate(const std::string &date_str)
{
    std::istringstream iss(date_str);
    int year, month, day;
    char dash;

    if (!(iss >> year >> dash && dash == '-' &&
          iss >> month >> dash && dash == '-' &&
          iss >> day))
    {
        LogError << ("Invalid date format") << ":" << date_str;
    }
    return {year, month, day};
}

// 减去指定天数
void DeleteExpiredFolderEngine::subtractDays(Date &date, int n_days)
{
    while (n_days > 0)
    {
        date.day--;
        n_days--;
        if (date.day == 0)
        {
            if (--date.month == 0)
            {
                --date.year;
                date.month = 12;
            }
            int max_days = daysInMonth(date.year, date.month);
            date.day = max_days;
        }
    }
}

// 格式化日期结构体为字符串
std::string DeleteExpiredFolderEngine::dateToStr(const Date &date)
{
    std::ostringstream oss;
    oss << date.year << "-" << std::setfill('0') << std::setw(2) << date.month << "-" << std::setw(2) << date.day;
    return oss.str();
}

// 主要功能函数，接收一个日期字符串和一个整数n，返回n天前的日期字符串
std::string DeleteExpiredFolderEngine::getDateBeforeNDays(const std::string &input_date, int n_days)
{
    try
    {
        Date date = strToDate(input_date);
        subtractDays(date, n_days);
        return dateToStr(date);
    }
    catch (const std::exception &e)
    {
        LogError << "Error: " << e.what();
        return "";
    }
}

void DeleteExpiredFolderEngine::getSubfolderNames(std::string &directory, std::vector<Date> &folder_names)
{
    if (directory.back() != '/')
        directory += "/";
    DIR *dir;
    struct dirent *ent;
    if ((dir = opendir(directory.c_str())) != nullptr)
    {
        while ((ent = readdir(dir)) != nullptr)
        {
            // 排除"."和".."
            if (ent->d_type == DT_DIR && ent->d_name[0] != '.' && ent->d_name != "best")
            {
                folder_names.push_back(strToDate(ent->d_name));
            }
        }
        closedir(dir);
    }
    else
    {
        LogError << "Unable to open directory: " << directory;
    }
}

void DeleteExpiredFolderEngine::deleteFolder(const std::string directory)
{
    std::string command = "rm -rf " + directory;
    int result = system(command.c_str());

    if (result != 0)
        std::cout << "Failed to remove directory recursively: " << directory << std::endl;
    else
        std::cout << "delete folder successfully : " << directory << std::endl;
}

// 删除向量中小于指定日期的所有元素
void DeleteExpiredFolderEngine::deleteEarlierDatesFolder(std::string &path, std::vector<Date> &subfolders, const Date &reference_date)
{
    if (path.back() != '/')
        path += "/";
    for (const Date &cur : subfolders)
    {
        // bool flag = false;
        if (cur.year < reference_date.year)
        {
            deleteFolder(path + dateToStr(cur));
        }
        else if (cur.year == reference_date.year && cur.month < reference_date.month)
        {
            deleteFolder(path + dateToStr(cur));
        }
        else if (cur.year == reference_date.year && cur.month == reference_date.month && cur.day < reference_date.day)
        {
            deleteFolder(path + dateToStr(cur));
        }
    }
}
\ No newline at end of file
diff --git a/engine/DetectDivideEngine/ContainerDivideEngine.cpp b/engine/DetectDivideEngine/ContainerDivideEngine.cpp
index 16a688f..afa27f1 100644
--- a/engine/DetectDivideEngine/ContainerDivideEngine.cpp
+++ b/engine/DetectDivideEngine/ContainerDivideEngine.cpp
@@ -1 +1 @@
-#include "ContainerDivideEngine.h"

#include <utility>


using namespace ai_matrix;

ContainerDivideEngine::ContainerDivideEngine() {}

ContainerDivideEngine::~ContainerDivideEngine() {}

APP_ERROR ContainerDivideEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";

    std::vector<DataSourceConfig> vecDataSourceConfig = Config::getins()->getAllDataSourceConfig();
    if (vecDataSourceConfig.size() <= this->engineId_)
    {
        LogWarn << " -- " << engineName_ << "_" << engineId_ << " dataSource no set, Engine DeInit";
        return APP_ERR_OK;
    }
    this->dataSourceConfig_ = vecDataSourceConfig.at(engineId_);
    this->baseConfig_ = Config::getins()->getBaseConfig();
    this->identifyConfig_ = Config::getins()->getIdentifyConfig();

    this->initParam();
    LogInfo << "DetectDivideEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerDivideEngine::DeInit()
{
    LogInfo << "DetectDivideEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 初始化参数信息
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void ContainerDivideEngine::initParam()
{
    this->iContainerIndex = 0;
    this->vecContainerFail_.clear();
}

void ContainerDivideEngine::sendBestData(const VSelectBestData& selectBestData)
{
    // 直接发送第一个箱子的箱号
    std::shared_ptr<VSelectBestData> pVSelectBestData = std::make_shared<VSelectBestData>();
    *pVSelectBestData = selectBestData;
    outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVSelectBestData), true);
    LogInfo << " 数据源:" << selectBestData.iDataSource
    << " 帧:" << selectBestData.iFrameId
    << " 节:" << selectBestData.iContainerIndex
    << "  发送识别结果  " << selectBestData.strNumResult;
    this->stdContainerResult_ = selectBestData.strNumResult;
    this->iContainerIndex++;
}

void ContainerDivideEngine::makeResult(const std::shared_ptr<VStep2OutputData>& pVStep2OutputData,
                                       VSelectBestData & selectBestData) const
{
    selectBestData.strDetectDate = pVStep2OutputData->strDetectDate;
    selectBestData.strDetectTime = pVStep2OutputData->strDetectTime;
    selectBestData.iDataSource = pVStep2OutputData->iDataSource;
    selectBestData.iFrameId = pVStep2OutputData->iFrameId;
    selectBestData.strNumResult = pVStep2OutputData->step2ResultData.transInfo.strTmpResult;
    selectBestData.bIsChkFlag = pVStep2OutputData->step2ResultData.transInfo.bIsChkFlag;
    selectBestData.fSumScore = pVStep2OutputData->step2ResultData.fSubScoreSum;
    selectBestData.iContainerIndex = this->iContainerIndex;
    selectBestData.bHaveTwoContainer = pVStep2OutputData->vecCornerResultData.size() > 2;

}

/**
* 处理车厢间隔
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void ContainerDivideEngine::divideInfo(std::shared_ptr<VStep2OutputData> pVStep2OutputData)
{
    auto vCompare = [](std::string a, std::string b) {
        if (a.size() != b.size()) return 999;

        int count = 0;
        for (int i = 0; i < a.size(); ++i)
        {
            if (a[i] != b[i])
            {
                ++count;
            }
        }
        return count;
    };

    if (!this->pVStep2OutputDataPre_) return;

    Step2ResultData step2ResultData_pre = this->pVStep2OutputDataPre_->step2ResultData;
    Step2ResultData step2ResultData = pVStep2OutputData->step2ResultData;

    float fCenterX = (step2ResultData.fRBX + step2ResultData.fLTX)/2;
    float fCenterY = (step2ResultData.fRBY + step2ResultData.fLTY)/2;
    float fCenterX_Pre = (step2ResultData_pre.fRBX + step2ResultData_pre.fLTX)/2;
    float fCenterY_Pre = (step2ResultData_pre.fRBY + step2ResultData_pre.fLTY)/2;

    if (this->iContainerIndex > 1) return;

    LogDebug << "-- 数据源:" << pVStep2OutputData->iDataSource
    << " 帧:" << pVStep2OutputData->iFrameId
    << " 实际Y:" << std::abs(fCenterY - fCenterY_Pre) << " 实际X:" << std::abs(fCenterX - fCenterX_Pre);
    if ((pVStep2OutputData->iDataSource == 0
         && std::abs(fCenterY - fCenterY_Pre) > this->identifyConfig_.iTop_Y_SplitSpanPx)
        ||
        (pVStep2OutputData->iDataSource != 0
         && std::abs(fCenterX - fCenterX_Pre) > this->identifyConfig_.iSide_X_SplitSpanPx))
    {
        if (step2ResultData.transInfo.bIsChkFlag)
        {
            if (stdContainerResult_ != step2ResultData.transInfo.strTmpResult)
            {
                if (stdContainerResult_.empty())
                {
                    // 筛选不满足校验的部分  取最长的发送
                    int iSize = 0, iIndex = 0;
                    std::string strContainer_tmp;
                    for (int i = 0; i < this->vecContainerFail_.size(); i++)
                    {
                        this->vecContainerFail_[i];
                        if (iSize < this->vecContainerFail_[i].strNumResult.size())
                        {
                            iSize = this->vecContainerFail_[i].strNumResult.size();
                            iIndex = i;
                            strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                        }
                    }

                    sendBestData(this->vecContainerFail_[iIndex]);
                }
                // 记录第二箱子
                this->vecContainerFail_.clear();
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->sendBestData(selectBestData);
            }
        }
        else
        {
            // 筛选不满足校验的部分  取最长的发送
            int iSize = 0, iIndex = 0;
            std::string strContainer_tmp;
            for (int i = 0; i < this->vecContainerFail_.size(); i++)
            {
                this->vecContainerFail_[i];
                if (iSize < this->vecContainerFail_[i].strNumResult.size())
                {
                    iSize = this->vecContainerFail_[i].strNumResult.size();
                    iIndex = i;
                    strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                }
            }
            if (this->vecContainerFail_.size() > 0 && this->iContainerIndex < 1)
            {
                sendBestData(this->vecContainerFail_[iIndex]);
            }

            // 把之前的清理掉再存新箱子的 （有风险，有可能切分错）
            this->vecContainerFail_.clear();
            VSelectBestData selectBestData;
            this->makeResult(pVStep2OutputData, selectBestData);
            this->vecContainerFail_.emplace_back(selectBestData);
        }
    }
    else
    {// 不满足像素差
        if (!this->stdContainerResult_.empty())
        {
            if (step2ResultData.transInfo.bIsChkFlag)
            {
                if (this->stdContainerResult_ != step2ResultData.transInfo.strTmpResult)
                {
//                    if (vCompare(this->stdContainerResult_, step2ResultData.transInfo.strTmpResult) > 2)
//                    {
                        this->vecContainerFail_.clear();
                        VSelectBestData selectBestData;
                        this->makeResult(pVStep2OutputData, selectBestData);
                        this->sendBestData(selectBestData);
//                    }
                }
            }
        }
        else
        {
            if (step2ResultData.transInfo.bIsChkFlag)
            {
                this->stdContainerResult_ = step2ResultData.transInfo.strTmpResult;
                this->vecContainerFail_.clear();
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->sendBestData(selectBestData);
            }
            else
            {
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->vecContainerFail_.emplace_back(selectBestData);
            }
        }
    }
}

APP_ERROR ContainerDivideEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        //pop端口0
        std::shared_ptr<void> pVoidData0 = nullptr;
        iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000);
            continue;
        }
        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::static_pointer_cast<VStep2OutputData>(pVoidData0);

        if (pVStep2OutputData->bIsEnd)
        {
            std::shared_ptr<VSelectBestData> pVSelectBestData = std::make_shared<VSelectBestData>();
            pVSelectBestData->bIsEnd = true;
            pVSelectBestData->iDataSource = pVStep2OutputData->iDataSource;

            if (this->iContainerIndex < 2 && this->vecContainerFail_.size() > 0)
            {
                // 筛选不满足校验的部分  取最长的发送
                int iSize = 0, iIndex = 0;
                std::string strContainer_tmp;
                for (int i = 0; i < this->vecContainerFail_.size(); i++)
                {
                    this->vecContainerFail_[i];
                    if (iSize < this->vecContainerFail_[i].strNumResult.size())
                    {
                        iSize = this->vecContainerFail_[i].strNumResult.size();
                        iIndex = i;
                        strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                    }
                }
                this->vecContainerFail_[iIndex].bIsEnd = true;
                sendBestData(this->vecContainerFail_[iIndex]);
                this->initParam();
                continue;
            }

            outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVSelectBestData), true);
            this->initParam();
            continue;
        }

        std::string strFilePath ;
        strFilePath = this->baseConfig_.strDebugResultPath + "/"
                + pVStep2OutputData->strDetectDate + "/"
                + StringUtil::getins()->replace_all_distinct(pVStep2OutputData->strDetectTime, ":", "-") + "/"
                + std::to_string(pVStep2OutputData->iFrameId) + "_" + std::to_string(pVStep2OutputData->iDataSource) + ".json";

        // 先读取文本内容，追加新的信息后再写入
        Json::Value jvFrameInfo;
        if (!FileUtil::getins()->readJsonInfo(jvFrameInfo, strFilePath))
        {
            LogError << "read fail:" << strFilePath;
        }
//        jvFrameInfo["isEnd"] = (pVStep2OutputData->bIsEnd || jvFrameInfo["isEnd"].asBool());

        // 识别结果存储
        float fCenter = pVStep2OutputData->step2ResultData.fLTX + (pVStep2OutputData->step2ResultData.fRBX - pVStep2OutputData->step2ResultData.fLTX) / 2;

//        this->mapContainerCenterInfo_.insert(std::make_pair(pVStep2OutputData->iFrameId, fCenter));

        Json::Value jvInfo;
        jvInfo["classid"] = pVStep2OutputData->step2ResultData.iClassId;
        jvInfo["score"] = pVStep2OutputData->step2ResultData.fScore;
        jvInfo["ltx"] = pVStep2OutputData->step2ResultData.fLTX;
        jvInfo["lty"] = pVStep2OutputData->step2ResultData.fLTY;
        jvInfo["rbx"] = pVStep2OutputData->step2ResultData.fRBX;
        jvInfo["rby"] = pVStep2OutputData->step2ResultData.fRBY;

        jvFrameInfo["step1"].append(jvInfo);

        for (auto &step2ResultData : pVStep2OutputData->vecCornerResultData)
        {
            float fCenter = step2ResultData.fLTX + (step2ResultData.fRBX - step2ResultData.fLTX) / 2;

//            this->mapContainerCenterInfo_.insert(std::make_pair(pVStep2OutputData->iFrameId, fCenter));

            Json::Value jvInfo;
            jvInfo["classid"] = step2ResultData.iClassId;
            jvInfo["score"] = step2ResultData.fScore;
            jvInfo["ltx"] = step2ResultData.fLTX;
            jvInfo["lty"] = step2ResultData.fLTY;
            jvInfo["rbx"] = step2ResultData.fRBX;
            jvInfo["rby"] = step2ResultData.fRBY;

            jvFrameInfo["step1"].append(jvInfo);
        }

        FileUtil::getins()->writeJsonInfo(jvFrameInfo, strFilePath);

        if (pVStep2OutputData->step2ResultData.fScore == 0.0f) continue;

        LogDebug << "数据源:" << pVStep2OutputData->iDataSource
        << " 帧:" << pVStep2OutputData->iFrameId
        << " - "<< pVStep2OutputData->step2ResultData.transInfo.strTmpResult;
        this->divideInfo(pVStep2OutputData);


        this->pVStep2OutputDataPre_ = pVStep2OutputData;
    }
    return APP_ERR_OK;
}
\ No newline at end of file
+#include "ContainerDivideEngine.h"

#include <utility>


using namespace ai_matrix;

ContainerDivideEngine::ContainerDivideEngine() {}

ContainerDivideEngine::~ContainerDivideEngine() {}

APP_ERROR ContainerDivideEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";

    std::vector<DataSourceConfig> vecDataSourceConfig = Config::getins()->getAllDataSourceConfig();
    if (vecDataSourceConfig.size() <= this->engineId_)
    {
        LogWarn << " -- " << engineName_ << "_" << engineId_ << " dataSource no set, Engine DeInit";
        return APP_ERR_OK;
    }
    this->dataSourceConfig_ = vecDataSourceConfig.at(engineId_);
    this->baseConfig_ = Config::getins()->getBaseConfig();
    this->identifyConfig_ = Config::getins()->getIdentifyConfig();

    this->initParam();
    LogInfo << "DetectDivideEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerDivideEngine::DeInit()
{
    LogInfo << "DetectDivideEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 初始化参数信息
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void ContainerDivideEngine::initParam()
{
    this->iContainerIndex = 0;
    this->vecContainerFail_.clear();
}

void ContainerDivideEngine::sendBestData(const VSelectBestData& selectBestData)
{
    // 直接发送第一个箱子的箱号
    std::shared_ptr<VSelectBestData> pVSelectBestData = std::make_shared<VSelectBestData>();
    *pVSelectBestData = selectBestData;
    outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVSelectBestData), true);
    LogInfo << " 数据源:" << selectBestData.iDataSource
    << " 帧:" << selectBestData.iFrameId
    << " 节:" << selectBestData.iContainerIndex
    << "  发送识别结果  " << selectBestData.strNumResult;
    this->stdContainerResult_ = selectBestData.strNumResult;
    this->iContainerIndex++;
}

void ContainerDivideEngine::makeResult(const std::shared_ptr<VStep2OutputData>& pVStep2OutputData,
                                       VSelectBestData & selectBestData) const
{
    selectBestData.strDetectDate = pVStep2OutputData->strDetectDate;
    selectBestData.strDetectTime = pVStep2OutputData->strDetectTime;
    selectBestData.iDataSource = pVStep2OutputData->iDataSource;
    selectBestData.iFrameId = pVStep2OutputData->iFrameId;
    selectBestData.strNumResult = pVStep2OutputData->step2ResultData.transInfo.strTmpResult;
    selectBestData.bIsChkFlag = pVStep2OutputData->step2ResultData.transInfo.bIsChkFlag;
    selectBestData.fSumScore = pVStep2OutputData->step2ResultData.fSubScoreSum;
    selectBestData.iContainerIndex = this->iContainerIndex;
    selectBestData.bHaveTwoContainer = pVStep2OutputData->vecCornerResultData.size() > 2;

}

/**
* 处理车厢间隔
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void ContainerDivideEngine::divideInfo(std::shared_ptr<VStep2OutputData> pVStep2OutputData)
{
    auto vCompare = [](std::string a, std::string b) {
        if (a.size() != b.size()) return 999;

        int count = 0;
        for (int i = 0; i < a.size(); ++i)
        {
            if (a[i] != b[i])
            {
                ++count;
            }
        }
        return count;
    };

    if (!this->pVStep2OutputDataPre_) return;

    Step2ResultData step2ResultData_pre = this->pVStep2OutputDataPre_->step2ResultData;
    Step2ResultData step2ResultData = pVStep2OutputData->step2ResultData;

    float fCenterX = (step2ResultData.fRBX + step2ResultData.fLTX)/2;
    float fCenterY = (step2ResultData.fRBY + step2ResultData.fLTY)/2;
    float fCenterX_Pre = (step2ResultData_pre.fRBX + step2ResultData_pre.fLTX)/2;
    float fCenterY_Pre = (step2ResultData_pre.fRBY + step2ResultData_pre.fLTY)/2;

    if (this->iContainerIndex > 1) return;

    LogDebug << "-- 数据源:" << pVStep2OutputData->iDataSource
    << " 帧:" << pVStep2OutputData->iFrameId
    << " 实际Y:" << std::abs(fCenterY - fCenterY_Pre) << " 实际X:" << std::abs(fCenterX - fCenterX_Pre);
    if ((pVStep2OutputData->iDataSource == 0
         && std::abs(fCenterY - fCenterY_Pre) > this->identifyConfig_.iTop_Y_SplitSpanPx)
        ||
        (pVStep2OutputData->iDataSource != 0
         && std::abs(fCenterX - fCenterX_Pre) > this->identifyConfig_.iSide_X_SplitSpanPx))
    {
        if (step2ResultData.transInfo.bIsChkFlag)
        {
            if (stdContainerResult_ != step2ResultData.transInfo.strTmpResult)
            {
                if (stdContainerResult_.empty())
                {
                    // 筛选不满足校验的部分  取最长的发送
                    int iSize = 0, iIndex = 0;
                    std::string strContainer_tmp;
                    for (int i = 0; i < this->vecContainerFail_.size(); i++)
                    {
                        this->vecContainerFail_[i];
                        if (iSize < this->vecContainerFail_[i].strNumResult.size())
                        {
                            iSize = this->vecContainerFail_[i].strNumResult.size();
                            iIndex = i;
                            strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                        }
                    }

                    sendBestData(this->vecContainerFail_[iIndex]);
                }
                // 记录第二箱子
                this->vecContainerFail_.clear();
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->sendBestData(selectBestData);
            }
        }
        else
        {
            // 筛选不满足校验的部分  取最长的发送
            int iSize = 0, iIndex = 0;
            std::string strContainer_tmp;
            for (int i = 0; i < this->vecContainerFail_.size(); i++)
            {
                this->vecContainerFail_[i];
                if (iSize < this->vecContainerFail_[i].strNumResult.size())
                {
                    iSize = this->vecContainerFail_[i].strNumResult.size();
                    iIndex = i;
                    strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                }
            }
            if (this->vecContainerFail_.size() > 0 && this->iContainerIndex < 1)
            {
                sendBestData(this->vecContainerFail_[iIndex]);
            }

            // 把之前的清理掉再存新箱子的 （有风险，有可能切分错）
            this->vecContainerFail_.clear();
            VSelectBestData selectBestData;
            this->makeResult(pVStep2OutputData, selectBestData);
            this->vecContainerFail_.emplace_back(selectBestData);
        }
    }
    else
    {// 不满足像素差
        if (!this->stdContainerResult_.empty())
        {
            if (step2ResultData.transInfo.bIsChkFlag)
            {
                if (this->stdContainerResult_ != step2ResultData.transInfo.strTmpResult)
                {
//                    if (vCompare(this->stdContainerResult_, step2ResultData.transInfo.strTmpResult) > 2)
//                    {
                        this->vecContainerFail_.clear();
                        VSelectBestData selectBestData;
                        this->makeResult(pVStep2OutputData, selectBestData);
                        this->sendBestData(selectBestData);
//                    }
                }
            }
        }
        else
        {
            if (step2ResultData.transInfo.bIsChkFlag)
            {
                this->stdContainerResult_ = step2ResultData.transInfo.strTmpResult;
                this->vecContainerFail_.clear();
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->sendBestData(selectBestData);
            }
            else
            {
                VSelectBestData selectBestData;
                this->makeResult(pVStep2OutputData, selectBestData);
                this->vecContainerFail_.emplace_back(selectBestData);
            }
        }
    }
}

APP_ERROR ContainerDivideEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        //pop端口0
        std::shared_ptr<void> pVoidData0 = nullptr;
        iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000);
            continue;
        }
        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::static_pointer_cast<VStep2OutputData>(pVoidData0);

        if (pVStep2OutputData->bIsEnd)
        {
            std::shared_ptr<VSelectBestData> pVSelectBestData = std::make_shared<VSelectBestData>();
            pVSelectBestData->bIsEnd = true;
            pVSelectBestData->iDataSource = pVStep2OutputData->iDataSource;
            pVSelectBestData->strDetectDate = pVStep2OutputData->strDetectDate;
            pVSelectBestData->strDetectTime = pVStep2OutputData->strDetectTime;

            if (this->iContainerIndex < 2 && this->vecContainerFail_.size() > 0)
            {
                // 筛选不满足校验的部分  取最长的发送
                int iSize = 0, iIndex = 0;
                std::string strContainer_tmp;
                for (int i = 0; i < this->vecContainerFail_.size(); i++)
                {
                    this->vecContainerFail_[i];
                    if (iSize < this->vecContainerFail_[i].strNumResult.size())
                    {
                        iSize = this->vecContainerFail_[i].strNumResult.size();
                        iIndex = i;
                        strContainer_tmp = this->vecContainerFail_[i].strNumResult;
                    }
                }
                this->vecContainerFail_[iIndex].bIsEnd = true;
                sendBestData(this->vecContainerFail_[iIndex]);
                this->initParam();
                continue;
            }

            outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVSelectBestData), true);
            this->initParam();
            continue;
        }

        std::string strFilePath ;
        strFilePath = this->baseConfig_.strDebugResultPath + "/"
                + pVStep2OutputData->strDetectDate + "/"
                + StringUtil::getins()->replace_all_distinct(pVStep2OutputData->strDetectTime, ":", "-") + "/"
                + std::to_string(pVStep2OutputData->iFrameId) + "_" + std::to_string(pVStep2OutputData->iDataSource) + ".json";

        // 先读取文本内容，追加新的信息后再写入
        Json::Value jvFrameInfo;
        if (!FileUtil::getins()->readJsonInfo(jvFrameInfo, strFilePath))
        {
            LogError << "read fail:" << strFilePath;
        }
//        jvFrameInfo["isEnd"] = (pVStep2OutputData->bIsEnd || jvFrameInfo["isEnd"].asBool());

        // 识别结果存储
        float fCenter = pVStep2OutputData->step2ResultData.fLTX + (pVStep2OutputData->step2ResultData.fRBX - pVStep2OutputData->step2ResultData.fLTX) / 2;

//        this->mapContainerCenterInfo_.insert(std::make_pair(pVStep2OutputData->iFrameId, fCenter));

        Json::Value jvInfo;
        jvInfo["classid"] = pVStep2OutputData->step2ResultData.iClassId;
        jvInfo["score"] = pVStep2OutputData->step2ResultData.fScore;
        jvInfo["ltx"] = pVStep2OutputData->step2ResultData.fLTX;
        jvInfo["lty"] = pVStep2OutputData->step2ResultData.fLTY;
        jvInfo["rbx"] = pVStep2OutputData->step2ResultData.fRBX;
        jvInfo["rby"] = pVStep2OutputData->step2ResultData.fRBY;

        jvFrameInfo["step1"].append(jvInfo);

        for (auto &step2ResultData : pVStep2OutputData->vecCornerResultData)
        {
            float fCenter = step2ResultData.fLTX + (step2ResultData.fRBX - step2ResultData.fLTX) / 2;

//            this->mapContainerCenterInfo_.insert(std::make_pair(pVStep2OutputData->iFrameId, fCenter));

            Json::Value jvInfo;
            jvInfo["classid"] = step2ResultData.iClassId;
            jvInfo["score"] = step2ResultData.fScore;
            jvInfo["ltx"] = step2ResultData.fLTX;
            jvInfo["lty"] = step2ResultData.fLTY;
            jvInfo["rbx"] = step2ResultData.fRBX;
            jvInfo["rby"] = step2ResultData.fRBY;

            jvFrameInfo["step1"].append(jvInfo);
        }

        FileUtil::getins()->writeJsonInfo(jvFrameInfo, strFilePath);

        if (pVStep2OutputData->step2ResultData.fScore == 0.0f) continue;

        LogDebug << "数据源:" << pVStep2OutputData->iDataSource
        << " 帧:" << pVStep2OutputData->iFrameId
        << " - "<< pVStep2OutputData->step2ResultData.transInfo.strTmpResult;
        this->divideInfo(pVStep2OutputData);


        this->pVStep2OutputDataPre_ = pVStep2OutputData;
    }
    return APP_ERR_OK;
}
\ No newline at end of file
diff --git a/engine/SaveDebugImageEngine/SaveDebugImageEngine.cpp b/engine/SaveDebugImageEngine/SaveDebugImageEngine.cpp
index effdd5d..70c8ac8 100644
--- a/engine/SaveDebugImageEngine/SaveDebugImageEngine.cpp
+++ b/engine/SaveDebugImageEngine/SaveDebugImageEngine.cpp
@@ -48,6 +48,7 @@ APP_ERROR SaveDebugImageEngine::Process()
             continue;
         }
 
+
         std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::static_pointer_cast<VStep2OutputData>(pvoidd);
 
         std::string strDataDir = this->baseConfig_.strDebugResultPath + "/"
@@ -64,6 +65,7 @@ APP_ERROR SaveDebugImageEngine::Process()
                 + "_"
                 + std::to_string(pVStep2OutputData->iDataSource) + ".jpg";
 
+        LogInfo << "strJsonPath:" << strJsonPath << "  strImagePath:" << strImagePath;
         Json::Value jvFrameInfo;
         if (!FileUtil::getins()->readJsonInfo(jvFrameInfo, strJsonPath))
         {
@@ -104,14 +106,22 @@ APP_ERROR SaveDebugImageEngine::Process()
                  cv::Point(centerX, pVStep2OutputData->step2ResultData.fLTY-30), cv::Point(centerX, pVStep2OutputData->step2ResultData.fRBY+30),
                  cvScalar, 1);
 
+        cv::Point linePoint(pVStep2OutputData->step2ResultData.fLTX + 10, pVStep2OutputData->step2ResultData.fRBY + 10);
+        cv::putText(image,
+                    pVStep2OutputData->step2ResultData.transInfo.strTmpResult,
+                    linePoint,
+                    cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 0, 180), 2);
+
         for (auto &step2ResultData : pVStep2OutputData->vecCornerResultData)
         {
+            cvScalar = {0, 255, 255, 255};
+            float centerX_corner = step2ResultData.fLTX + (step2ResultData.fRBX - step2ResultData.fLTX)/2;
             cv::rectangle(image,
                           cv::Point(step2ResultData.fLTX, step2ResultData.fLTY),
                           cv::Point(step2ResultData.fRBX, step2ResultData.fRBY),
                           cvScalar, 2);
             cv::line(image,
-                     cv::Point(centerX, step2ResultData.fLTY-30), cv::Point(centerX, step2ResultData.fRBY+30),
+                     cv::Point(centerX_corner, step2ResultData.fLTY-30), cv::Point(centerX_corner, step2ResultData.fRBY+30),
                      cvScalar, 1);
         }
 
diff --git a/engine/SaveResultCSVEngine/SaveResultCSVEngine.cpp b/engine/SaveResultCSVEngine/SaveResultCSVEngine.cpp
index 390dd47..0f1f226 100644
--- a/engine/SaveResultCSVEngine/SaveResultCSVEngine.cpp
+++ b/engine/SaveResultCSVEngine/SaveResultCSVEngine.cpp
@@ -1 +1 @@
-#include "SaveResultCSVEngine.h"

using namespace ai_matrix;

SaveResultCSVEngine::SaveResultCSVEngine() {}

SaveResultCSVEngine::~SaveResultCSVEngine() {}

APP_ERROR SaveResultCSVEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";

    this->baseConfig_ = Config::getins()->getBaseConfig();

    LogInfo << "SaveResultCSVEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR SaveResultCSVEngine::DeInit()
{
    LogInfo << "SaveResultCSVEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 保存车厢的最优结果到CSV中
* inParam : std::shared_ptr<Train> pTrain   :列车信息
* outParam:
* return  : true/false
*/
bool SaveResultCSVEngine::saveTrainCsv(std::shared_ptr<DetectResultData> pDetectResultData)
{
    //1. 创建保存路径 (固定路径/YYYY-MM-DD/hh-mm-ss/)
    if (!FileUtil::getins()->createDirPath(this->baseConfig_.strResultPath))
    {
        LogError << "日期:" << pDetectResultData->strDetectDate << " csv save err";
        return false;
    }

    //2. 保存csv
    std::string strCsvName = pDetectResultData->strDetectDate + ".csv";
    std::string strCsvPath = this->baseConfig_.strResultPath + "/" + strCsvName;

    bool bIsExsit = false;
    if (access(strCsvPath.c_str(), F_OK) != -1)
    {
        bIsExsit = true;
    }

    try
    {
        // 写文件
        std::ofstream outFile;
        outFile.open(strCsvPath, std::ios::app);

        if (!bIsExsit)
        {
            outFile << "Time" << ','
                    << "Container" << ','
                    << "Image"
                    << std::endl;
        }

        std::string strContainerNo;
        for (int i = 0; i < pDetectResultData->vecContainerNO.size(); ++i)
        {
            strContainerNo += pDetectResultData->vecContainerNO[i];
            if (i < pDetectResultData->vecContainerNO.size() - 1)
            {
                strContainerNo += "-";
            }
        }
        outFile << pDetectResultData->strDetectTime << ','
                << strContainerNo << ','
                << ""
                << std::endl;

        outFile.close();
    }
    catch (const std::exception &)
    {
        LogError << "strCsvPath:" << strCsvPath << " train savecsv fail!";
        return false;
    }
    return true;
}


APP_ERROR SaveResultCSVEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        //pop端口0 车厢信息
        std::shared_ptr<void> pVoidData0 = nullptr;
        iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000);
            continue;
        }

        std::shared_ptr<DetectResultData> pDetectResultData = std::static_pointer_cast<DetectResultData>(pVoidData0);

        this->saveTrainCsv(pDetectResultData);

    }
    return APP_ERR_OK;
}
\ No newline at end of file
+#include "SaveResultCSVEngine.h"

using namespace ai_matrix;

SaveResultCSVEngine::SaveResultCSVEngine() {}

SaveResultCSVEngine::~SaveResultCSVEngine() {}

APP_ERROR SaveResultCSVEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";

    this->baseConfig_ = Config::getins()->getBaseConfig();

    LogInfo << "SaveResultCSVEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR SaveResultCSVEngine::DeInit()
{
    LogInfo << "SaveResultCSVEngine DeInit ok";
    return APP_ERR_OK;
}

/**
* 保存车厢的最优结果到CSV中
* inParam : std::shared_ptr<Train> pTrain   :列车信息
* outParam:
* return  : true/false
*/
bool SaveResultCSVEngine::saveTrainCsv(std::shared_ptr<DetectResultData> pDetectResultData)
{
    //1. 创建保存路径 (固定路径/YYYY-MM-DD/hh-mm-ss/)
    if (!FileUtil::getins()->createDirPath(this->baseConfig_.strResultPath))
    {
        LogError << "日期:" << pDetectResultData->strDetectDate << " csv save err";
        return false;
    }

    //2. 保存csv
    std::string strCsvName = pDetectResultData->strDetectDate + ".csv";
    std::string strCsvPath = this->baseConfig_.strResultPath + "/"
            + pDetectResultData->strDetectDate + "/"
            + strCsvName;

    LogInfo << strCsvPath;

    bool bIsExsit = false;
    if (access(strCsvPath.c_str(), F_OK) != -1)
    {
        bIsExsit = true;
    }

    try
    {
        // 写文件
        std::ofstream outFile;
        outFile.open(strCsvPath, std::ios::app);

        if (!bIsExsit)
        {
            outFile << "Time" << ','
                    << "Container" << ','
                    << "Image"
                    << std::endl;
        }

        std::string strContainerNo;
        for (const auto & containerNo_it : pDetectResultData->vecContainerNO)
        {
            strContainerNo += "[";
            strContainerNo += containerNo_it;
            strContainerNo += "]";
        }
        std::string strImage;
        for (const auto & image_it : pDetectResultData->vecImage)
        {
            strContainerNo += "[";
            strContainerNo += image_it;
            strContainerNo += "]";

            std::string strDebugImage = this->baseConfig_.strDebugResultPath + "/"
                                        + pDetectResultData->strDetectDate + "/"
                                        + StringUtil::getins()->replace_all_distinct(pDetectResultData->strDetectTime, ":", "-")
                                        + "/" + image_it;
            std::string strResultImage = this->baseConfig_.strResultPath + "/"
                                        + pDetectResultData->strDetectDate + "/"
                                        + StringUtil::getins()->replace_all_distinct(pDetectResultData->strDetectTime, ":", "-")
                                        + "/" + image_it;
            FileUtil::getins()->copyFile(strDebugImage, strResultImage);
        }

        outFile << pDetectResultData->strDetectTime << ','
                << strContainerNo << ','
                << strImage << ','
                << std::endl;

        outFile.close();


    }
    catch (const std::exception &)
    {
        LogError << "strCsvPath:" << strCsvPath << " train savecsv fail!";
        return false;
    }
    return true;
}


APP_ERROR SaveResultCSVEngine::Process()
{
    int iRet = APP_ERR_OK;
    while (!isStop_)
    {
        //pop端口0 车厢信息
        std::shared_ptr<void> pVoidData0 = nullptr;
        iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000);
            continue;
        }

        std::shared_ptr<DetectResultData> pDetectResultData = std::static_pointer_cast<DetectResultData>(pVoidData0);

        this->saveTrainCsv(pDetectResultData);

    }
    return APP_ERR_OK;
}
\ No newline at end of file
diff --git a/engine/SelectBestEngine/SelectBestEngine.cpp b/engine/SelectBestEngine/SelectBestEngine.cpp
index 1632b1b..0f59f4f 100644
--- a/engine/SelectBestEngine/SelectBestEngine.cpp
+++ b/engine/SelectBestEngine/SelectBestEngine.cpp
@@ -10,9 +10,11 @@ APP_ERROR SelectBestEngine::Init()
 {
     strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
     strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";
+    strPort2_ = engineName_ + "_" + std::to_string(engineId_) + "_2";
 
     this->baseConfig_ = Config::getins()->getBaseConfig();
     this->minioConfig_ = Config::getins()->getMinioConfig();
+    this->vecDataSourceConfig_ = Config::getins()->getAllDataSourceConfig();
 
     this->initParam();
 
@@ -86,7 +88,7 @@ void SelectBestEngine::sendSaveCSV(DetectResultData &detectResultData)
 {
     std::shared_ptr<DetectResultData> pDetectResultData = std::make_shared<DetectResultData>();
     *pDetectResultData = detectResultData;
-    outputQueMap_[strPort1_]->push(std::static_pointer_cast<void>(pDetectResultData));
+    outputQueMap_[strPort2_]->push(std::static_pointer_cast<void>(pDetectResultData));
 }
 
 /**
@@ -174,7 +176,7 @@ APP_ERROR SelectBestEngine::Process()
         if (pVSelectBestData->bIsEnd)
         {
             this->iEndCount_++;
-            if (!(this->iEndCount_ % 3))
+            if (!(this->iEndCount_ % this->vecDataSourceConfig_.size()))
             {
                 this->selectBest();
                 this->initParam();
@@ -182,7 +184,7 @@ APP_ERROR SelectBestEngine::Process()
             continue;
         }
 
-        if (!this->strImagePath_.empty())
+        if (this->strImagePath_.empty())
         {
             this->strDetectDate_ = pVSelectBestData->strDetectDate;
             this->strDetectTime_ = pVSelectBestData->strDetectTime;
diff --git a/engine/SelectBestEngine/SelectBestEngine.h b/engine/SelectBestEngine/SelectBestEngine.h
index 0116098..1e831b2 100644
--- a/engine/SelectBestEngine/SelectBestEngine.h
+++ b/engine/SelectBestEngine/SelectBestEngine.h
@@ -31,9 +31,11 @@ private:
 
     std::string strPort0_;
     std::string strPort1_;
+    std::string strPort2_;
 
     ai_matrix::BaseConfig baseConfig_;
     ai_matrix::MinioConfig minioConfig_;
+    std::vector<ai_matrix::DataSourceConfig> vecDataSourceConfig_;
 
     std::string strImagePath_;
     std::string strDetectDate_;
diff --git a/engine/Step1InferenceEngine/ContainerStep1InferenceEngine.cpp b/engine/Step1InferenceEngine/ContainerStep1InferenceEngine.cpp
index 16f9d65..d7bf862 100644
--- a/engine/Step1InferenceEngine/ContainerStep1InferenceEngine.cpp
+++ b/engine/Step1InferenceEngine/ContainerStep1InferenceEngine.cpp
@@ -258,6 +258,8 @@ APP_ERROR ContainerStep1InferenceEngine::Process()
         std::shared_ptr<InferenceResultData> pInferenceResultData = std::make_shared<InferenceResultData>();
         pInferenceResultData->iDataSource = pVDetectInfo->iDataSource;
         pInferenceResultData->bIsEnd = pVDetectInfo->bIsEnd;
+        pInferenceResultData->strDetectDate = pVDetectInfo->strDetectDate;
+        pInferenceResultData->strDetectTime = pVDetectInfo->strDetectTime;
         if (pVDetectInfo->bIsEnd)
         {
             outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pInferenceResultData), true);
diff --git a/engine/Step2InferenceEngine/ContainerStep2InferenceEngine.cpp b/engine/Step2InferenceEngine/ContainerStep2InferenceEngine.cpp
index 3f9e170..bf6eac9 100644
--- a/engine/Step2InferenceEngine/ContainerStep2InferenceEngine.cpp
+++ b/engine/Step2InferenceEngine/ContainerStep2InferenceEngine.cpp
@@ -1 +1 @@
-#include "ContainerStep2InferenceEngine.h"
#include <opencv2/opencv.hpp>
#include "myqueue.h"

using namespace ai_matrix;

ContainerStep2InferenceEngine::ContainerStep2InferenceEngine() {}

ContainerStep2InferenceEngine::~ContainerStep2InferenceEngine() {}

APP_ERROR ContainerStep2InferenceEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    this->modelConfig_ = Config::getins()->getModelByContainerStep2Config();

    //读取模型信息
    int iFolderExist = access(modelConfig_.strModelPath.c_str(), R_OK);
    if (iFolderExist == -1)
    {
        LogError << "模型：" << modelConfig_.strModelPath << " 不存在!";
        return false;
    }
    class_num = this->modelConfig_.vecClass.size();
    score_threshold = this->modelConfig_.fScoreThreshold;
    input_size = GET_INPUT_SIZE(model_width , model_height);
    output_size = GET_OUTPUT_SIZE(model_width, model_height, clear_num, class_num);
    det_size = clear_num + class_num + 5;

    int ret = initModel();
    if (ret != APP_ERR_OK)
    {
        LogError << "Failed to read model info, ret = " << ret;
        return ret;
    }

    LogInfo << "ContainerStep2InferenceEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerStep2InferenceEngine::initModel()
{

    modelinfo.yolov5ClearityModelParam.uiClassNum = class_num;
    modelinfo.yolov5ClearityModelParam.uiClearNum = clear_num;
    modelinfo.yolov5ClearityModelParam.uiDetSize = det_size;
    modelinfo.yolov5ClearityModelParam.fScoreThreshold = score_threshold;
    modelinfo.yolov5ClearityModelParam.fNmsThreshold = nms_threshold;

    modelinfo.modelCommonInfo.uiModelWidth = model_width;
    modelinfo.modelCommonInfo.uiModelHeight = model_height;
    modelinfo.modelCommonInfo.uiInputSize = input_size;
    modelinfo.modelCommonInfo.uiOutputSize = output_size;
    modelinfo.modelCommonInfo.uiChannel = INPUT_CHANNEL;
    modelinfo.modelCommonInfo.uiBatchSize = batch_size;
    modelinfo.modelCommonInfo.strInputBlobName = INPUT_BLOB_NAME;
    modelinfo.modelCommonInfo.strOutputBlobName = OUTPUT_BLOB_NAME;

    string strModelName;

    int nRet = yolov5model.YoloV5ClearityInferenceInit(&modelinfo,
                                                       strModelName,
                                                       this->modelConfig_.strModelPath);
    if (nRet != 0)
    {
        LogInfo << "YoloV5ClassifyInferenceInit nRet:" << nRet;
        return APP_ERR_COMM_READ_FAIL;
    }
    return APP_ERR_OK;
}

APP_ERROR ContainerStep2InferenceEngine::DeInit()
{
    yolov5model.YoloV5ClearityInferenceDeinit();
    LogInfo << "ContainerStep2InferenceEngine DeInit ok";
    return APP_ERR_OK;
}

void ContainerStep2InferenceEngine::resetLocation(SingleData &singleData, SingleData &step1SingleData, float fResizeRatio)
{
    singleData.fLTX = singleData.fLTX * fResizeRatio + step1SingleData.fLTX;
    singleData.fLTY = singleData.fLTY * fResizeRatio + step1SingleData.fLTY;
    singleData.fRBX = singleData.fRBX * fResizeRatio + step1SingleData.fLTX;
    singleData.fRBY = singleData.fRBY * fResizeRatio + step1SingleData.fLTY;

    singleData.fLTX = (singleData.fLTX < IMAGE_WIDTH) ? singleData.fLTX : IMAGE_WIDTH;
    singleData.fLTY = (singleData.fLTY < IMAGE_HEIGHT) ? singleData.fLTY : IMAGE_HEIGHT;
    singleData.fRBX = (singleData.fRBX < IMAGE_WIDTH) ? singleData.fRBX : IMAGE_WIDTH;
    singleData.fRBY = (singleData.fRBY < IMAGE_HEIGHT) ? singleData.fRBY : IMAGE_HEIGHT;
}

APP_ERROR ContainerStep2InferenceEngine::Process()
{
    int iRet = APP_ERR_OK;

    while (!isStop_)
    {
        std::shared_ptr<void> pVoidData0 = nullptr;
        inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000); //1ms
            continue;
        }

        std::shared_ptr<InferenceResultData> pInferenceResultData = std::static_pointer_cast<InferenceResultData>(pVoidData0);

        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::make_shared<VStep2OutputData>();
        pVStep2OutputData->iDataSource = pInferenceResultData->iDataSource;
        pVStep2OutputData->bIsEnd = pInferenceResultData->bIsEnd;
        if (pInferenceResultData->bIsEnd)
        {
            outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
            continue;
        }

        pVStep2OutputData->strDetectDate = pInferenceResultData->strDetectDate;
        pVStep2OutputData->strDetectTime = pInferenceResultData->strDetectTime;
        pVStep2OutputData->iFrameId = pInferenceResultData->iFrameId;

//        LogWarn << "-- 0  -->" << pVStep2InputData->vecSingleData.size();
        for (auto & single : pInferenceResultData->vecSingleData)
        {
            Step2ResultData step2ResultData;
            step2ResultData.fLTX = single.fLTX;
            step2ResultData.fLTY = single.fLTY;
            step2ResultData.fRBX = single.fRBX;
            step2ResultData.fRBY = single.fRBY;
            step2ResultData.iClassId = single.iClassId;
            step2ResultData.fScore = single.fScore;
            step2ResultData.iTrainIndex = single.iTrainIndex;

            if (single.iTargetType == CORNER)
            {
                pVStep2OutputData->vecCornerResultData.emplace_back(step2ResultData);
                continue;
            };
        }

        if (pInferenceResultData->singleData.fScore > 0.0f)
        {
            pVStep2OutputData->step2ResultData.fLTX = pInferenceResultData->singleData.fLTX;
            pVStep2OutputData->step2ResultData.fLTY = pInferenceResultData->singleData.fLTY;
            pVStep2OutputData->step2ResultData.fRBX = pInferenceResultData->singleData.fRBX;
            pVStep2OutputData->step2ResultData.fRBY = pInferenceResultData->singleData.fRBY;
            pVStep2OutputData->step2ResultData.iClassId = pInferenceResultData->singleData.iClassId;
            pVStep2OutputData->step2ResultData.fScore = pInferenceResultData->singleData.fScore;
            pVStep2OutputData->step2ResultData.iTrainIndex = pInferenceResultData->singleData.iTrainIndex;

            cv::Rect rect(cv::Point(pInferenceResultData->singleData.fLTX, pInferenceResultData->singleData.fLTY),
                          cv::Point(pInferenceResultData->singleData.fRBX, pInferenceResultData->singleData.fRBY));
            cv::Mat image = pInferenceResultData->cvImage(rect).clone();

            //进行推理
            std::vector<stDetection> vecInferenceResult;
            auto start = std::chrono::system_clock::now(); // 计时开始
            yolov5model.YoloV5ClearityInferenceModel(image, vecInferenceResult, 2);
            auto end = std::chrono::system_clock::now();

            for (const auto & j : vecInferenceResult)
            {
                if (j.class_conf < STEP2_SCORE_THRESH)
                {
                    continue;
                }
                SingleData singledata;
                singledata.iLine = j.clear_id;
                singledata.iClassId = j.class_id;
                singledata.fScore = j.class_conf;
                singledata.fLTX = j.bbox[0];
                singledata.fLTY = j.bbox[1];
                singledata.fRBX = j.bbox[2];
                singledata.fRBY = j.bbox[3];

                this->resetLocation(singledata, pInferenceResultData->singleData);
                pVStep2OutputData->step2ResultData.vecSingleData.emplace_back(singledata);

//                LogDebug << "frameId:" << pVStep2OutputData->iFrameId
//                         << " --iClassId:" << singledata.iClassId
//                         << " iLine:" << singledata.iLine
//                         << " score=" << singledata.fScore
//                         << " ["
//                         << singledata.fLTX << "," << singledata.fLTY
//                         << "],["
//                         << singledata.fRBX << "," << singledata.fRBY
//                         << "]";
            }
        }

        outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
    }
    return APP_ERR_OK;
}

\ No newline at end of file
+#include "ContainerStep2InferenceEngine.h"
#include <opencv2/opencv.hpp>
#include "myqueue.h"

using namespace ai_matrix;

ContainerStep2InferenceEngine::ContainerStep2InferenceEngine() {}

ContainerStep2InferenceEngine::~ContainerStep2InferenceEngine() {}

APP_ERROR ContainerStep2InferenceEngine::Init()
{
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    this->modelConfig_ = Config::getins()->getModelByContainerStep2Config();

    //读取模型信息
    int iFolderExist = access(modelConfig_.strModelPath.c_str(), R_OK);
    if (iFolderExist == -1)
    {
        LogError << "模型：" << modelConfig_.strModelPath << " 不存在!";
        return false;
    }
    class_num = this->modelConfig_.vecClass.size();
    score_threshold = this->modelConfig_.fScoreThreshold;
    input_size = GET_INPUT_SIZE(model_width , model_height);
    output_size = GET_OUTPUT_SIZE(model_width, model_height, clear_num, class_num);
    det_size = clear_num + class_num + 5;

    int ret = initModel();
    if (ret != APP_ERR_OK)
    {
        LogError << "Failed to read model info, ret = " << ret;
        return ret;
    }

    LogInfo << "ContainerStep2InferenceEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR ContainerStep2InferenceEngine::initModel()
{

    modelinfo.yolov5ClearityModelParam.uiClassNum = class_num;
    modelinfo.yolov5ClearityModelParam.uiClearNum = clear_num;
    modelinfo.yolov5ClearityModelParam.uiDetSize = det_size;
    modelinfo.yolov5ClearityModelParam.fScoreThreshold = score_threshold;
    modelinfo.yolov5ClearityModelParam.fNmsThreshold = nms_threshold;

    modelinfo.modelCommonInfo.uiModelWidth = model_width;
    modelinfo.modelCommonInfo.uiModelHeight = model_height;
    modelinfo.modelCommonInfo.uiInputSize = input_size;
    modelinfo.modelCommonInfo.uiOutputSize = output_size;
    modelinfo.modelCommonInfo.uiChannel = INPUT_CHANNEL;
    modelinfo.modelCommonInfo.uiBatchSize = batch_size;
    modelinfo.modelCommonInfo.strInputBlobName = INPUT_BLOB_NAME;
    modelinfo.modelCommonInfo.strOutputBlobName = OUTPUT_BLOB_NAME;

    string strModelName;

    int nRet = yolov5model.YoloV5ClearityInferenceInit(&modelinfo,
                                                       strModelName,
                                                       this->modelConfig_.strModelPath);
    if (nRet != 0)
    {
        LogInfo << "YoloV5ClassifyInferenceInit nRet:" << nRet;
        return APP_ERR_COMM_READ_FAIL;
    }
    return APP_ERR_OK;
}

APP_ERROR ContainerStep2InferenceEngine::DeInit()
{
    yolov5model.YoloV5ClearityInferenceDeinit();
    LogInfo << "ContainerStep2InferenceEngine DeInit ok";
    return APP_ERR_OK;
}

void ContainerStep2InferenceEngine::resetLocation(SingleData &singleData, SingleData &step1SingleData, float fResizeRatio)
{
    singleData.fLTX = singleData.fLTX * fResizeRatio + step1SingleData.fLTX;
    singleData.fLTY = singleData.fLTY * fResizeRatio + step1SingleData.fLTY;
    singleData.fRBX = singleData.fRBX * fResizeRatio + step1SingleData.fLTX;
    singleData.fRBY = singleData.fRBY * fResizeRatio + step1SingleData.fLTY;

    singleData.fLTX = (singleData.fLTX < IMAGE_WIDTH) ? singleData.fLTX : IMAGE_WIDTH;
    singleData.fLTY = (singleData.fLTY < IMAGE_HEIGHT) ? singleData.fLTY : IMAGE_HEIGHT;
    singleData.fRBX = (singleData.fRBX < IMAGE_WIDTH) ? singleData.fRBX : IMAGE_WIDTH;
    singleData.fRBY = (singleData.fRBY < IMAGE_HEIGHT) ? singleData.fRBY : IMAGE_HEIGHT;
}

APP_ERROR ContainerStep2InferenceEngine::Process()
{
    int iRet = APP_ERR_OK;

    while (!isStop_)
    {
        std::shared_ptr<void> pVoidData0 = nullptr;
        inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000); //1ms
            continue;
        }

        std::shared_ptr<InferenceResultData> pInferenceResultData = std::static_pointer_cast<InferenceResultData>(pVoidData0);

        std::shared_ptr<VStep2OutputData> pVStep2OutputData = std::make_shared<VStep2OutputData>();
        pVStep2OutputData->iDataSource = pInferenceResultData->iDataSource;
        pVStep2OutputData->bIsEnd = pInferenceResultData->bIsEnd;
        pVStep2OutputData->strDetectDate = pInferenceResultData->strDetectDate;
        pVStep2OutputData->strDetectTime = pInferenceResultData->strDetectTime;
        if (pInferenceResultData->bIsEnd)
        {
            outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
            continue;
        }

        pVStep2OutputData->strDetectDate = pInferenceResultData->strDetectDate;
        pVStep2OutputData->strDetectTime = pInferenceResultData->strDetectTime;
        pVStep2OutputData->iFrameId = pInferenceResultData->iFrameId;

//        LogWarn << "-- 0  -->" << pVStep2InputData->vecSingleData.size();
        for (auto & single : pInferenceResultData->vecSingleData)
        {
            Step2ResultData step2ResultData;
            step2ResultData.fLTX = single.fLTX;
            step2ResultData.fLTY = single.fLTY;
            step2ResultData.fRBX = single.fRBX;
            step2ResultData.fRBY = single.fRBY;
            step2ResultData.iClassId = single.iClassId;
            step2ResultData.fScore = single.fScore;
            step2ResultData.iTrainIndex = single.iTrainIndex;

            if (single.iTargetType == CORNER)
            {
                pVStep2OutputData->vecCornerResultData.emplace_back(step2ResultData);
                continue;
            };
        }

        if (pInferenceResultData->singleData.fScore > 0.0f)
        {
            pVStep2OutputData->step2ResultData.fLTX = pInferenceResultData->singleData.fLTX;
            pVStep2OutputData->step2ResultData.fLTY = pInferenceResultData->singleData.fLTY;
            pVStep2OutputData->step2ResultData.fRBX = pInferenceResultData->singleData.fRBX;
            pVStep2OutputData->step2ResultData.fRBY = pInferenceResultData->singleData.fRBY;
            pVStep2OutputData->step2ResultData.iClassId = pInferenceResultData->singleData.iClassId;
            pVStep2OutputData->step2ResultData.fScore = pInferenceResultData->singleData.fScore;
            pVStep2OutputData->step2ResultData.iTrainIndex = pInferenceResultData->singleData.iTrainIndex;

            cv::Rect rect(cv::Point(pInferenceResultData->singleData.fLTX, pInferenceResultData->singleData.fLTY),
                          cv::Point(pInferenceResultData->singleData.fRBX, pInferenceResultData->singleData.fRBY));
            cv::Mat image = pInferenceResultData->cvImage(rect).clone();

            //进行推理
            std::vector<stDetection> vecInferenceResult;
            auto start = std::chrono::system_clock::now(); // 计时开始
            yolov5model.YoloV5ClearityInferenceModel(image, vecInferenceResult, 2);
            auto end = std::chrono::system_clock::now();

            for (const auto & j : vecInferenceResult)
            {
                if (j.class_conf < STEP2_SCORE_THRESH)
                {
                    continue;
                }
                SingleData singledata;
                singledata.iLine = j.clear_id;
                singledata.iClassId = j.class_id;
                singledata.fScore = j.class_conf;
                singledata.fLTX = j.bbox[0];
                singledata.fLTY = j.bbox[1];
                singledata.fRBX = j.bbox[2];
                singledata.fRBY = j.bbox[3];

                this->resetLocation(singledata, pInferenceResultData->singleData);
                pVStep2OutputData->step2ResultData.vecSingleData.emplace_back(singledata);

//                LogDebug << "frameId:" << pVStep2OutputData->iFrameId
//                         << " --iClassId:" << singledata.iClassId
//                         << " iLine:" << singledata.iLine
//                         << " score=" << singledata.fScore
//                         << " ["
//                         << singledata.fLTX << "," << singledata.fLTY
//                         << "],["
//                         << singledata.fRBX << "," << singledata.fRBY
//                         << "]";
            }
        }

        outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pVStep2OutputData), true);
    }
    return APP_ERR_OK;
}

\ No newline at end of file
diff --git a/engine/WSServerEngine/WSServerEngine.cpp b/engine/WSServerEngine/WSServerEngine.cpp
index 4391f03..e88228e 100644
--- a/engine/WSServerEngine/WSServerEngine.cpp
+++ b/engine/WSServerEngine/WSServerEngine.cpp
@@ -143,7 +143,7 @@ void WSServerEngine::stop()
 std::string WSServerEngine::onCMD(CMDConnData &conn, int argc, const char **argv)
 {
     std::string msg = argv[0];
-    std::string strShow = "WebSocket收到 " + conn.ip + " 的信息：" + msg;
+    std::string strShow = "VCarContainer 收到 " + conn.ip + " 的信息：" + msg;
     LogInfo << strShow;
     outputQueMap_[strPort0_]->push(std::static_pointer_cast<std::string>(std::make_shared<std::string>(msg)), true);
     this->sendAllClient(strShow);