909 lines
30 KiB
C++
909 lines
30 KiB
C++
#include "SelectBestSecondaryEngine.h"
|
||
|
||
using namespace ai_matrix;
|
||
|
||
SelectBestSecondaryEngine::SelectBestSecondaryEngine() {}
|
||
|
||
SelectBestSecondaryEngine::~SelectBestSecondaryEngine() {}
|
||
|
||
APP_ERROR SelectBestSecondaryEngine::Init()
|
||
{
|
||
strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
|
||
strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";
|
||
|
||
this->baseConfig_ = Config::getins()->getBaseConfig();
|
||
this->dataSourceConfig_ = Config::getins()->getDataSourceConfig();
|
||
this->identifyConfig_ = Config::getins()->getIdentifyConfig();
|
||
|
||
InitParam();
|
||
LogInfo << "SelectBestSecondaryEngine Init ok";
|
||
return APP_ERR_OK;
|
||
}
|
||
|
||
APP_ERROR SelectBestSecondaryEngine::DeInit()
|
||
{
|
||
LogInfo << "SelectBestSecondaryEngine DeInit ok";
|
||
return APP_ERR_OK;
|
||
}
|
||
|
||
/**
|
||
* 初始化集装箱参数信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::InitContainerParam()
|
||
{
|
||
this->fCenter_X_pre_ = 0.0f;
|
||
iContainerIndex_ = 0;
|
||
mapContainerInfo_.clear();
|
||
// strBestContainerImg_ = "";
|
||
// fMaxScoreSumContainer_ = 0;
|
||
|
||
mapBestContainerImg_.clear();
|
||
mapMaxScoreSumContainer_.clear();
|
||
// memset(&step1BestContainer_, 0, sizeof(step1BestContainer_));
|
||
for (auto &it : mapStep1BestContainer_)
|
||
{
|
||
it.second = step1BestContainer_;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 初始化车号参数信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::InitNumParam()
|
||
{
|
||
mapTrainTypeId_.clear();
|
||
mapNumInfo_.clear();
|
||
strBestNumImg_ = "";
|
||
fMaxScoreSumNum_ = 0;
|
||
memset(&step1BestNum_, 0, sizeof(step1BestNum_));
|
||
}
|
||
|
||
/**
|
||
* 初始化属性参数信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::InitProParam()
|
||
{
|
||
mapProInfo_.clear();
|
||
strBestProImg_ = "";
|
||
fMaxScoreSumPro_ = 0;
|
||
memset(&step1BestPro_, 0, sizeof(step1BestPro_));
|
||
}
|
||
|
||
/**
|
||
* 初始化车号参数信息(只有车结束调用)
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::InitHeadParam()
|
||
{
|
||
mapHeadInfo_.clear();
|
||
strBestHeadImg_ = "";
|
||
fMaxScoreSumHead_ = 0;
|
||
memset(&step1BestHead_, 0, sizeof(step1BestHead_));
|
||
}
|
||
|
||
/**
|
||
* 初始化参数信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::InitParam()
|
||
{
|
||
InitContainerParam();
|
||
InitNumParam();
|
||
InitProParam();
|
||
InitHeadParam();
|
||
}
|
||
|
||
/**
|
||
* 获取最优长度
|
||
* inParam : std::vector<TransInfo> &vecAllTransInfo 待汇总取优的结果集
|
||
* : TargetMaxLen iMaxLen 目标最大长度
|
||
* outParam: N/A
|
||
* return : 最优长度
|
||
*/
|
||
int SelectBestSecondaryEngine::GetBestLength(std::vector<TransInfo> &vecAllTransInfo, TargetMaxLen iMaxLen)
|
||
{
|
||
//1.获取结果中每种长度出现的次数
|
||
std::map<int, int> mapResultSize;
|
||
for (size_t i = 0; i < vecAllTransInfo.size(); i++)
|
||
{
|
||
int iNowSize = vecAllTransInfo[i].vecValue.size();
|
||
if (mapResultSize.find(iNowSize) != mapResultSize.end())
|
||
{
|
||
mapResultSize[iNowSize]++;
|
||
continue;
|
||
}
|
||
mapResultSize[iNowSize] = 1;
|
||
}
|
||
|
||
int iBestLen = 0;
|
||
//2.获取最优长度
|
||
if (iSelectBestMode_ == FREQUENCY)
|
||
{
|
||
//2.1 按长度出现的频次最多，作为最优长度
|
||
int iCnt = 0;
|
||
for (auto it = mapResultSize.begin(); it != mapResultSize.end(); it++)
|
||
{
|
||
if (iCnt < it->second && it->first <= iMaxLen)
|
||
{
|
||
iCnt = it->second;
|
||
iBestLen = it->first;
|
||
}
|
||
}
|
||
}
|
||
else if (iSelectBestMode_ == LENGTH)
|
||
{
|
||
//2.2 按最长长度且不能大于最大长度，作为最优长度
|
||
for (auto rit = mapResultSize.rbegin(); rit != mapResultSize.rend(); rit++)
|
||
{
|
||
if (rit->first <= iMaxLen)
|
||
{
|
||
iBestLen = rit->first;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return iBestLen;
|
||
}
|
||
|
||
/**
|
||
* 获取最优结果
|
||
* inParam : std::vector<TransInfo> &vecAllTransInfo 待汇总取优的结果集
|
||
* : TargetMaxLen iMaxLen 目标最大长度
|
||
* outParam: N/A
|
||
* return : 最优结果
|
||
*/
|
||
std::string SelectBestSecondaryEngine::GetBest(std::vector<TransInfo> &vecAllTransInfo, TargetMaxLen iMaxLen)
|
||
{
|
||
std::string strValue = "";
|
||
if (vecAllTransInfo.size() <= 0)
|
||
{
|
||
LogInfo << "<<< --- 没数据 --- >>>";
|
||
return strValue;
|
||
}
|
||
|
||
//优先使用校验通过的数据选优。
|
||
std::vector<TransInfo> vecTransInfoTemp;
|
||
for (size_t i = 0; i < vecAllTransInfo.size(); i++)
|
||
{
|
||
TransInfo transInfo = vecAllTransInfo[i];
|
||
if (transInfo.IsChkFlag)
|
||
{
|
||
vecTransInfoTemp.emplace_back(transInfo);
|
||
}
|
||
}
|
||
if (vecTransInfoTemp.size() > 0)
|
||
{
|
||
vecAllTransInfo = vecTransInfoTemp;
|
||
} else {
|
||
// LogInfo << "--->>> 没有符合正则的？？";
|
||
// 此处因车厢太脏。识别效果很差，难以与RFID识别结果融合，所以增加eles
|
||
return strValue;
|
||
}
|
||
|
||
//获取最优长度
|
||
int iBestLen = GetBestLength(vecAllTransInfo, iMaxLen);
|
||
// LogInfo << "--->>> 最优长度：" << iBestLen;
|
||
|
||
//初始化最优结果
|
||
TransInfo transInfoBest;
|
||
transInfoBest.vecScore.reserve(iBestLen);
|
||
transInfoBest.vecValue.reserve(iBestLen);
|
||
for (int i = 0; i < iBestLen; i++)
|
||
{
|
||
transInfoBest.vecScore.emplace_back(0);
|
||
transInfoBest.vecValue.emplace_back("");
|
||
}
|
||
|
||
std::map<std::string, int> mapResult; //符合最优长度的结果集 [key:结果; value:结果出现次数]
|
||
for (size_t iIndex = 0; iIndex < vecAllTransInfo.size(); iIndex++)
|
||
{
|
||
if (vecAllTransInfo[iIndex].vecValue.size() != iBestLen)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
std::string strValueTemp;
|
||
for (int j = 0; j < iBestLen; j++)
|
||
{
|
||
strValueTemp += vecAllTransInfo[iIndex].vecValue[j];
|
||
if (transInfoBest.vecScore[j] < vecAllTransInfo[iIndex].vecScore[j])
|
||
{
|
||
transInfoBest.vecScore[j] = vecAllTransInfo[iIndex].vecScore[j];
|
||
transInfoBest.vecValue[j] = vecAllTransInfo[iIndex].vecValue[j];
|
||
}
|
||
}
|
||
|
||
if (mapResult.find(strValueTemp) != mapResult.end())
|
||
{
|
||
mapResult[strValueTemp]++;
|
||
}
|
||
else
|
||
{
|
||
mapResult[strValueTemp] = 1;
|
||
}
|
||
}
|
||
|
||
//按字符最高得分汇总结果
|
||
for (size_t i = 0; i < transInfoBest.vecValue.size(); ++i)
|
||
{
|
||
strValue += transInfoBest.vecValue[i];
|
||
}
|
||
|
||
//按出现次数汇总结果
|
||
int iMaxCnt = 0;
|
||
std::string strValue2;
|
||
for (auto iter = mapResult.begin(); iter != mapResult.end(); iter++)
|
||
{
|
||
if (iter->second > iMaxCnt)
|
||
{
|
||
iMaxCnt = iter->second;
|
||
strValue2 = iter->first;
|
||
}
|
||
}
|
||
|
||
//最高得分汇总和最高次数汇总不相等，且识别同一结果次数大于等于3次，则使用按次数汇总结果。
|
||
if (strValue != strValue2)
|
||
{
|
||
// LogWarn << "engineId:" << engineId_ << " value1:" << strValue << " value2:" << strValue2
|
||
// << " not equal value2cnt:" << iMaxCnt;
|
||
if (iMaxCnt >= 3)
|
||
{
|
||
strValue = strValue2;
|
||
}
|
||
}
|
||
|
||
return strValue;
|
||
}
|
||
|
||
/**
|
||
* 集装箱数据加入到待选优集合中
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData :处理帧数据
|
||
: TransSubData &transSubData :转换后子数据
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::containerAddSelectBestMap(const int iFrameId, const Step2ResultData &step2ResultData)
|
||
{
|
||
float fCenter_X = (step2ResultData.fLTX + step2ResultData.fRBX)/2;
|
||
|
||
for (const auto& transInfo : step2ResultData.vecTransInfo)
|
||
{
|
||
if (std::abs(fCenter_X - this->fCenter_X_pre_) > this->identifyConfig_.iContainerSplitFrameSpanPx && this->fCenter_X_pre_)
|
||
{
|
||
bool bSplit = true;
|
||
for (auto &it_pre : this->mapContainerInfo_[this->iContainerIndex_])
|
||
{
|
||
if (transInfo.strTmpResult == it_pre.strTmpResult)
|
||
{
|
||
bSplit = false;
|
||
break;
|
||
}
|
||
}
|
||
if (bSplit)
|
||
{
|
||
// LogDebug << "fCenter_X_pre_:" << fCenter_X_pre_
|
||
// << " fCenter_X:" << fCenter_X
|
||
// << " --- " << this->identifyConfig_.iSplitFrameSpanPx;
|
||
this->iContainerIndex_++;
|
||
}
|
||
|
||
}
|
||
// LogDebug << " Index_:" << this->iContainerIndex_
|
||
// << " info:" << transInfo.strTmpResult;
|
||
this->mapContainerInfo_[this->iContainerIndex_].emplace_back(transInfo);
|
||
this->fCenter_X_pre_ = fCenter_X;
|
||
}
|
||
|
||
//最高分和最优帧号
|
||
if (this->mapMaxScoreSumContainer_.find(this->iContainerIndex_) == this->mapMaxScoreSumContainer_.end()
|
||
|| this->mapMaxScoreSumContainer_[this->iContainerIndex_] <= step2ResultData.fSubScoreSum)
|
||
{
|
||
this->mapMaxScoreSumContainer_[this->iContainerIndex_] = step2ResultData.fSubScoreSum;
|
||
this->mapBestContainerImg_[this->iContainerIndex_] = std::to_string(iFrameId) + ".jpg";
|
||
this->mapStep1BestContainer_[this->iContainerIndex_] = step2ResultData;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 车号数据加入到待选优集合中
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData :处理帧数据
|
||
: TransSubData &transSubData :转换后子数据
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::numAddSelectBestMap(const int iFrameId, const Step2ResultData &step2ResultData)
|
||
{
|
||
for (size_t i = 0; i < step2ResultData.vecTransInfo.size(); i++)
|
||
{
|
||
TransInfo transInfo = step2ResultData.vecTransInfo[i];
|
||
mapNumInfo_[transInfo.iLine].emplace_back(transInfo);
|
||
}
|
||
|
||
//记录车厢类型ID
|
||
if (mapTrainTypeId_.find(step2ResultData.iClassId) != mapTrainTypeId_.end())
|
||
{
|
||
mapTrainTypeId_[step2ResultData.iClassId]++;
|
||
}
|
||
else
|
||
{
|
||
mapTrainTypeId_[step2ResultData.iClassId] = 1;
|
||
}
|
||
|
||
//最高分和最优帧号
|
||
if (fMaxScoreSumNum_ < step2ResultData.fSubScoreSum)
|
||
{
|
||
fMaxScoreSumNum_ = step2ResultData.fSubScoreSum;
|
||
strBestNumImg_ = std::to_string(iFrameId) + ".jpg";
|
||
step1BestNum_ = step2ResultData;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 属性数据加入到待选优集合中
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData :处理帧数据
|
||
: TransSubData &transSubData :转换后子数据
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::proAddSelectBestMap(const int iFrameId, const Step2ResultData &step2ResultData)
|
||
{
|
||
for (size_t i = 0; i < step2ResultData.vecTransInfo.size(); i++)
|
||
{
|
||
TransInfo transInfo = step2ResultData.vecTransInfo[i];
|
||
mapProInfo_[transInfo.iLine].emplace_back(transInfo);
|
||
}
|
||
|
||
//最高分和最优帧号
|
||
if (fMaxScoreSumPro_ < step2ResultData.fSubScoreSum)
|
||
{
|
||
fMaxScoreSumPro_ = step2ResultData.fSubScoreSum;
|
||
strBestProImg_ = std::to_string(iFrameId) + ".jpg";
|
||
step1BestPro_ = step2ResultData;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 车头数据加入到待选优集合中
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData :处理帧数据
|
||
: TransSubData &transSubData :转换后子数据
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::headAddSelectBestMap(const int iFrameId, const Step2ResultData &step2ResultData)
|
||
{
|
||
// for (size_t i = 0; i < step2ResultData.vecTransInfo.size(); i++)
|
||
// {
|
||
// TransInfo transInfo = step2ResultData.vecTransInfo[i];
|
||
// this->mapHeadInfo_[transInfo.iLine].emplace_back(transInfo);
|
||
// }
|
||
//
|
||
// //记录车头大框识别次数
|
||
// auto iter = this->mapTrainTypeId_.find(0);
|
||
// if (iter == this->mapTrainTypeId_.end())
|
||
// {
|
||
// this->mapTrainTypeId_.insert(std::make_pair(0, 1));
|
||
// }
|
||
// else
|
||
// {
|
||
// iter->second++;
|
||
// }
|
||
//
|
||
// //最高分和最优帧号
|
||
// if (fMaxScoreSumHead_ < step2ResultData.fSubScoreSum)
|
||
// {
|
||
// fMaxScoreSumHead_ = step2ResultData.fSubScoreSum;
|
||
// strBestHeadImg_ = std::to_string(iFrameId) + ".jpg";
|
||
// step1BestHead_ = step2ResultData;
|
||
// }
|
||
}
|
||
|
||
/**
|
||
* 汇总车头最佳值
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
//bool SelectBestSecondaryEngine::getHeadBest(std::shared_ptr<ProcessData> pProcessData)
|
||
//{
|
||
// //2.无识别车头信息，不汇总
|
||
// if (mapHeadInfo_.empty())
|
||
// {
|
||
// LogDebug << "engineId:" << engineId_ << " no head info";
|
||
// return false;
|
||
// }
|
||
//
|
||
// std::shared_ptr<VTrainInfo> pTrain = std::make_shared<VTrainInfo>();
|
||
//
|
||
// //车头型号
|
||
// if (mapHeadInfo_.find(0) != mapHeadInfo_.end())
|
||
// {
|
||
// pTrain->strTType = GetBest(mapHeadInfo_.at(0), TYPE_MAXLEN);
|
||
// }
|
||
//
|
||
// //车头编号
|
||
// if (mapHeadInfo_.find(1) != mapHeadInfo_.end())
|
||
// {
|
||
// pTrain->strTNum = GetBest(mapHeadInfo_.at(1), NUM_MAXLEN);
|
||
// }
|
||
//
|
||
// pTrain->strTNum_image = strBestHeadImg_;
|
||
// pTrain->numCoordinate.iClassId = step1BestHead_.iClassId;
|
||
// pTrain->numCoordinate.fScore = step1BestHead_.fScore;
|
||
// pTrain->numCoordinate.fLTX = step1BestHead_.fLTX;
|
||
// pTrain->numCoordinate.fLTY = step1BestHead_.fLTY;
|
||
// pTrain->numCoordinate.fRBX = step1BestHead_.fRBX;
|
||
// pTrain->numCoordinate.fRBY = step1BestHead_.fRBY;
|
||
// pTrain->numCoordinate.strClassName = "HEARD";
|
||
// pTrain->iCategory = 0; //车头
|
||
//
|
||
//
|
||
// //push端口1，车头属性
|
||
// pTrain->trainPro.iDataSource = iDataSourceHead_;
|
||
// pTrain->trainPro.bIsEnd = pProcessData->bIsEnd;
|
||
// pTrain->trainPro.strTrainDate = pProcessData->strTrainDate;
|
||
// pTrain->trainPro.strTrainName = pProcessData->strTrainName;
|
||
// pTrain->trainPro.iDirection = pProcessData->iDirection;
|
||
// pTrain->trainPro.iCarXH = 0;
|
||
//
|
||
// pTrain->strTrainDate = pTrain->trainNum.strTrainDate;
|
||
// pTrain->strTrainName = pTrain->trainNum.strTrainName;
|
||
// pTrain->iDirection = pTrain->trainNum.iDirection;
|
||
// pTrain->iDataSource = pTrain->trainNum.iDataSource >= pTrain->trainPro.iDataSource ? pTrain->trainNum.iDataSource : pTrain->trainPro.iDataSource;
|
||
//
|
||
// LogInfo << "\n ---汇总结果--- \n"
|
||
// << "日期时间: " << pTrain->strTrainDate << " " << pTrain->strTrainName << "\n"
|
||
// << "车厢序号: " << pTrain->iCarXH << "\n"
|
||
// << "车型Id: " << pTrain->trainNum.iTrainTypeId << "\n"
|
||
// << "车型: " << pTrain->trainNum.strTrainType << "\n"
|
||
// << "车号: " << pTrain->trainNum.strTrainNum << "\n"
|
||
// << "载重: " << pTrain->trainPro.strLoad << "\n"
|
||
// << "自重: " << pTrain->trainPro.strSelf << "\n"
|
||
// << "容积: " << pTrain->trainPro.strVolume << "\n"
|
||
// << "换长: " << pTrain->trainPro.strChange << "\n"
|
||
// << "容量记表: " << pTrain->trainPro.strVolumeSurface << "\n"
|
||
// << "编号图片: " << pTrain->trainNum.strBestImg << "\n"
|
||
// << "属性图片: " << pTrain->trainPro.strBestImg << "\n"
|
||
// << "行驶方向: " << pTrain->iDirection << "\n"
|
||
// << " ---汇总结果 END--- ";
|
||
//
|
||
// //拷贝最优图片到最优路径下
|
||
// CopyBestImgToBestPath(pTrain);
|
||
//
|
||
// std::shared_ptr<Train> pTrainToCsv = std::make_shared<Train>();
|
||
// *pTrainToCsv = *pTrain;
|
||
// PushData(strPort0_, pTrain);
|
||
// PushData(strPort1_, pTrainToCsv);
|
||
// return true;
|
||
//}
|
||
|
||
/**
|
||
* 汇总集装箱最佳值
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::getContainerBest(VTrainInfo &train, std::shared_ptr<VStep2OutputData> pVStep2OutputData)
|
||
{
|
||
int i = 0;
|
||
for (auto &it : mapContainerInfo_)
|
||
{
|
||
VContainer vContainer;
|
||
vContainer.strContainerNo = GetBest(it.second, CONTAINER_MAXLEN);
|
||
vContainer.strImg = this->mapBestContainerImg_[i];
|
||
VCoordinate vCoordinate;
|
||
vCoordinate.iClassId = this->mapStep1BestContainer_[i].iClassId;
|
||
vCoordinate.fLTX = this->mapStep1BestContainer_[i].fLTX;
|
||
vCoordinate.fLTY = this->mapStep1BestContainer_[i].fLTY;
|
||
vCoordinate.fRBX = this->mapStep1BestContainer_[i].fRBX;
|
||
vCoordinate.fRBY = this->mapStep1BestContainer_[i].fRBY;
|
||
vCoordinate.fScore = this->mapStep1BestContainer_[i].fScore;
|
||
vCoordinate.strClassName = "CONTAINER";
|
||
|
||
vContainer.coordinate = vCoordinate;
|
||
train.vecContainer.emplace_back(vContainer);
|
||
++i;
|
||
if (i > 1) break;
|
||
}
|
||
//初始化车号信息
|
||
InitContainerParam();
|
||
}
|
||
|
||
/**
|
||
* 汇总车号最佳值
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData
|
||
* outParam: TrainNum &trainNum
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::getNumBest(VTrainInfo &train, std::shared_ptr<VStep2OutputData> pVStep2OutputData)
|
||
{
|
||
//车型
|
||
if (mapNumInfo_.find(0) != mapNumInfo_.end())
|
||
{
|
||
train.strTType = GetBest(mapNumInfo_.at(0), TYPE_MAXLEN);
|
||
// LogInfo << "-->>> " << trainNum.strTrainType;
|
||
}
|
||
//编号
|
||
if (mapNumInfo_.find(1) != mapNumInfo_.end())
|
||
{
|
||
train.strTNum = GetBest(mapNumInfo_.at(1), NUM_MAXLEN);
|
||
}
|
||
|
||
//按出现次数选车厢类型ID
|
||
int iMaxCnt = 0;
|
||
for (auto iter = mapTrainTypeId_.begin(); iter != mapTrainTypeId_.end(); iter++)
|
||
{
|
||
if (iter->second > iMaxCnt)
|
||
{
|
||
iMaxCnt = iter->second;
|
||
train.iCategory = iter->first;
|
||
}
|
||
}
|
||
|
||
train.strTNum_image = strBestNumImg_;
|
||
train.numCoordinate.iClassId = step1BestNum_.iClassId;
|
||
train.numCoordinate.fScore = step1BestNum_.fScore;
|
||
train.numCoordinate.fLTX = step1BestNum_.fLTX;
|
||
train.numCoordinate.fLTY = step1BestNum_.fLTY;
|
||
train.numCoordinate.fRBX = step1BestNum_.fRBX;
|
||
train.numCoordinate.fRBY = step1BestNum_.fRBY;
|
||
train.numCoordinate.strClassName = "NUM";
|
||
//初始化车号信息
|
||
InitNumParam();
|
||
}
|
||
|
||
/**
|
||
* 汇总属性最佳值
|
||
* inParam : std::shared_ptr<ProcessData> pProcessData
|
||
* outParam: TrainPro &trainPro
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::getProBest(VTrainInfo &train, std::shared_ptr<VStep2OutputData> pVStep2OutputData)
|
||
{
|
||
//载重
|
||
if (mapProInfo_.find(0) != mapProInfo_.end())
|
||
{
|
||
train.strTLoadWeight = GetBest(mapProInfo_.at(0), LOAD_MAXLEN);
|
||
}
|
||
//自重
|
||
if (mapProInfo_.find(1) != mapProInfo_.end())
|
||
{
|
||
train.strTTareWeight = GetBest(mapProInfo_.at(1), SELF_MAXLEN);
|
||
if (train.strTTareWeight.length() == 3)
|
||
{
|
||
train.strTTareWeight = train.strTTareWeight.substr(0, 2) + "." + train.strTTareWeight.substr(2, 1);
|
||
}
|
||
}
|
||
//容积
|
||
if (mapProInfo_.find(2) != mapProInfo_.end())
|
||
{
|
||
train.strTVolume = GetBest(mapProInfo_.at(2), VOLUME_MAXLEN);
|
||
//棚车容器一般为1开头得三位整数，因此不需要额外补小数点处理。
|
||
if (train.strTVolume.length() == 3 && train.strTVolume.substr(0, 1) != "1")
|
||
{
|
||
train.strTVolume = train.strTVolume.substr(0, 2) + "." + train.strTVolume.substr(2, 1);
|
||
}
|
||
}
|
||
|
||
//换长
|
||
if (mapProInfo_.find(3) != mapProInfo_.end())
|
||
{
|
||
train.strTChangeLen = GetBest(mapProInfo_.at(3), CHANGE_MAXLEN);
|
||
if (train.strTChangeLen.length() == 1)
|
||
{
|
||
if (train.strTChangeLen.at(0) != '1')
|
||
{
|
||
train.strTChangeLen = "1." + train.strTChangeLen;
|
||
}
|
||
}
|
||
else if (train.strTChangeLen.length() == 2)
|
||
{
|
||
train.strTChangeLen = train.strTChangeLen.substr(0, 1) + "." + train.strTChangeLen.substr(1, 1);
|
||
}
|
||
}
|
||
|
||
train.strTPro_image = strBestProImg_;
|
||
train.proCoordinate.iClassId = step1BestPro_.iClassId;
|
||
train.proCoordinate.fScore = step1BestPro_.fScore;
|
||
train.proCoordinate.fLTX = step1BestPro_.fLTX;
|
||
train.proCoordinate.fLTY = step1BestPro_.fLTY;
|
||
train.proCoordinate.fRBX = step1BestPro_.fRBX;
|
||
train.proCoordinate.fRBY = step1BestPro_.fRBY;
|
||
train.proCoordinate.strClassName = "PRO";
|
||
//初始化属性信息
|
||
InitProParam();
|
||
}
|
||
|
||
/**
|
||
* 拷贝最优图片到最优路径下
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::copyBestImgToBestPath(const VTrainInfo &train)
|
||
{
|
||
std::string strSrc = this->baseConfig_.strDebugResultPath + "/" + train.strTrainDate + "/" + train.strTrainName + "/jpg_" + std::to_string(train.iDataSource) + "/";
|
||
std::string strDes = this->baseConfig_.strResultPath + "/" + train.strTrainDate + "/" + train.strTrainName + "/";
|
||
if (!FileUtil::getins()->createDirPath(strDes))
|
||
{
|
||
LogError << "engineId:" << engineId_ << " CreateDirPath err strDes:" << strDes;
|
||
return;
|
||
}
|
||
|
||
//拷贝最优图片到最优路径下
|
||
if (!train.strTNum_image.empty())
|
||
{
|
||
FileUtil::getins()->copyFile(strSrc + train.strTNum_image, strDes + train.strTNum_image);
|
||
}
|
||
if (!train.strTPro_image.empty())
|
||
{
|
||
FileUtil::getins()->copyFile(strSrc + train.strTPro_image, strDes + train.strTPro_image);
|
||
}
|
||
|
||
for (auto &it_container : train.vecContainer)
|
||
{
|
||
FileUtil::getins()->copyFile(strSrc + it_container.strImg, strDes + it_container.strImg);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/**
|
||
* 汇总车厢最佳值
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void SelectBestSecondaryEngine::getTrainBest(std::shared_ptr<VStep2OutputData> pVStep2OutputData)
|
||
{
|
||
VTrainInfo train;
|
||
//1.汇总车号信息
|
||
this->getNumBest(train, pVStep2OutputData);
|
||
|
||
//2.汇总属性信息
|
||
this->getProBest(train, pVStep2OutputData);
|
||
|
||
//3.汇总集装箱信息
|
||
this->getContainerBest(train, pVStep2OutputData);
|
||
|
||
// 修正载重
|
||
for (std::map<std::string, std::string>::iterator it =
|
||
this->mapLoad_.begin();
|
||
it != this->mapLoad_.end(); ++it) {
|
||
if (train.strTType.find(it->first) !=
|
||
std::string::npos) {
|
||
train.strTLoadWeight = it->second;
|
||
}
|
||
}
|
||
// 修正容积
|
||
if (train.iCategory == 6)
|
||
{
|
||
train.strTVolume = "";
|
||
}
|
||
train.iDataSource = pVStep2OutputData->iDataSource;
|
||
train.strTrainDate = pVStep2OutputData->strTrainDate;
|
||
train.strTrainTime = pVStep2OutputData->strTrainTime;
|
||
train.strTrainName = pVStep2OutputData->strTrainName;
|
||
train.strTrackName = this->baseConfig_.strTrackName;
|
||
train.iCarOrder = this->partionInfo_.iTrainIndex;
|
||
train.iStartFrame = this->partionInfo_.iStartframe;
|
||
train.iEndFrame = this->partionInfo_.iEndframe;
|
||
|
||
std::string strFirameJsonDir = this->baseConfig_.strDebugResultPath + "/"
|
||
+ pVStep2OutputData->strTrainDate + "/"
|
||
+ pVStep2OutputData->strTrainName + "/"
|
||
+ "jpg_" + std::to_string(pVStep2OutputData->iDataSource) + "/";
|
||
|
||
std::string strStartFramePath = strFirameJsonDir + std::to_string(train.iStartFrame) + ".json";
|
||
|
||
Json::Value jvStartFrameJson;
|
||
if (FileUtil::getins()->readJsonInfo(jvStartFrameJson, strStartFramePath))
|
||
{
|
||
// train.iTDirection = jvStartFrameJson.isMember("direction") ? jvStartFrameJson["direction"].asInt() : 0;
|
||
train.strStartTime = jvStartFrameJson.isMember("timeStamp") ? jvStartFrameJson["timeStamp"].asString() : "";
|
||
}
|
||
|
||
std::string strEndFramePath = strFirameJsonDir + std::to_string(train.iEndFrame) + ".json";
|
||
|
||
Json::Value jvEndFrameJson;
|
||
if (FileUtil::getins()->readJsonInfo(jvEndFrameJson, strEndFramePath))
|
||
{
|
||
train.iTDirection = jvStartFrameJson.isMember("direction") ? jvStartFrameJson["direction"].asInt() : 0;
|
||
train.bIsTheLast = jvEndFrameJson.isMember("isEnd") ? jvEndFrameJson["isEnd"].asBool() : false;
|
||
train.strEndTime = jvEndFrameJson.isMember("timeStamp") ? jvEndFrameJson["timeStamp"].asString() : "";
|
||
}
|
||
|
||
int iFrameFirst = 0;
|
||
switch (this->dataSourceConfig_.iDirection)
|
||
{
|
||
case DIRECTION_LEFT:
|
||
iFrameFirst = this->dataSourceConfig_.iLeftFirst;
|
||
break;
|
||
case DIRECTION_RIGHT:
|
||
iFrameFirst = this->dataSourceConfig_.iRightFirst;
|
||
break;
|
||
case DIRECTION_UNKNOWN:
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (train.strTNum_image.empty())
|
||
{
|
||
switch (iFrameFirst)
|
||
{
|
||
case LEFT_RUN_AND_NUM_FIRST:
|
||
case RIGHT_RUN_AND_NUM_FIRST:
|
||
train.strTNum_image = std::to_string(train.iStartFrame) + ".jpg";
|
||
break;
|
||
case LEFT_RUN_AND_PRO_FIRST:
|
||
case RIGHT_RUN_AND_PRO_FIRST:
|
||
train.strTNum_image = std::to_string(train.iEndFrame) + ".jpg";
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (train.strTPro_image.empty())
|
||
{
|
||
switch (iFrameFirst)
|
||
{
|
||
case LEFT_RUN_AND_PRO_FIRST:
|
||
case RIGHT_RUN_AND_PRO_FIRST:
|
||
train.strTPro_image = std::to_string(train.iStartFrame) + ".jpg";
|
||
break;
|
||
case LEFT_RUN_AND_NUM_FIRST:
|
||
case RIGHT_RUN_AND_NUM_FIRST:
|
||
train.strTPro_image = std::to_string(train.iEndFrame) + ".jpg";
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
std::string strContainer, strContainerImage;
|
||
|
||
for (int i = 0; i < train.vecContainer.size(); i++)
|
||
{
|
||
strContainer += train.vecContainer[i].strContainerNo;
|
||
strContainerImage += train.vecContainer[i].strImg;
|
||
if (i < train.vecContainer.size() - 1)
|
||
{
|
||
strContainer += ",";
|
||
strContainerImage += ",";
|
||
}
|
||
|
||
}
|
||
|
||
LogInfo << "\n ---辅助摄像头汇总结果--- \n"
|
||
<< "数据源: " << train.iDataSource << "\n"
|
||
<< "日期时间: " << train.strTrainDate << " " << train.strTrainTime << "\n"
|
||
<< "股道: " << train.strTrackName << "\n"
|
||
<< "行驶方向: " << train.iTDirection << "\n"
|
||
<< "车厢序号: " << train.iCarOrder << "\n"
|
||
<< "车型Id: " << train.iCategory << "\n"
|
||
<< "车型: " << train.strTType << "\n"
|
||
<< "车号: " << train.strTNum << "\n"
|
||
<< "载重: " << train.strTLoadWeight << "\n"
|
||
<< "自重: " << train.strTTareWeight << "\n"
|
||
<< "容积: " << train.strTVolume << "\n"
|
||
<< "换长: " << train.strTChangeLen << "\n"
|
||
<< "编号图片: " << train.strTNum_image << "\n"
|
||
<< "属性图片: " << train.strTPro_image << "\n"
|
||
<< "车节开始时间: " << train.strStartTime << "\n"
|
||
<< "车节结束时间: " << train.strEndTime << "\n"
|
||
<< "集装箱：" << strContainer << "\n"
|
||
<< "集装箱图片：" << strContainerImage << "\n"
|
||
<< " ---汇总结果 END--- ";
|
||
|
||
//拷贝最优图片到最优路径下
|
||
this->copyBestImgToBestPath(train);
|
||
|
||
std::shared_ptr<VTrainInfo> pTrain = std::make_shared<VTrainInfo>();
|
||
*pTrain = train;
|
||
outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pTrain));
|
||
}
|
||
|
||
bool SelectBestSecondaryEngine::readPartionJson(std::string &strJsonPath, PartionInfo &partionInfo)
|
||
{
|
||
if (access(strJsonPath.c_str(), F_OK) != 0)
|
||
{
|
||
LogWarn << "文件:" << strJsonPath << " 不存在";
|
||
return false;
|
||
}
|
||
|
||
Json::Value jvInfo;
|
||
if (!FileUtil::getins()->readJsonInfo(jvInfo, strJsonPath))
|
||
{
|
||
LogError << "读取json文件失败:" << strJsonPath;
|
||
return false;
|
||
}
|
||
|
||
partionInfo.iStartframe = jvInfo["startFrame"].asInt();
|
||
partionInfo.iEndframe = jvInfo["endFrame"].asInt();
|
||
partionInfo.iTrainIndex = jvInfo["trainIndex"].asInt();
|
||
return true;
|
||
}
|
||
|
||
APP_ERROR SelectBestSecondaryEngine::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);
|
||
|
||
for (size_t i = 0; i < pVStep2OutputData->vecStep2ResultData.size(); i++)
|
||
{
|
||
Step2ResultData step2ResultData = pVStep2OutputData->vecStep2ResultData[i];
|
||
|
||
if (step2ResultData.iTrainIndex != this->partionInfo_.iTrainIndex)
|
||
{
|
||
std::string strJsonPath = this->baseConfig_.strDebugResultPath + "/"
|
||
+ pVStep2OutputData->strTrainDate + "/"
|
||
+ pVStep2OutputData->strTrainName + "/"
|
||
+ "secondary_" + std::to_string(step2ResultData.iTrainIndex)
|
||
+ ".json";
|
||
if (!this->readPartionJson(strJsonPath, this->partionInfo_)) continue;
|
||
}
|
||
|
||
switch (step2ResultData.iClassId)
|
||
{
|
||
case TRAIN_HEAD:
|
||
//车头加入待汇总集合中
|
||
this->headAddSelectBestMap(pVStep2OutputData->iFrameId, step2ResultData);
|
||
break;
|
||
case TRAIN_PRO:
|
||
//属性加入待汇总集合中
|
||
this->proAddSelectBestMap(pVStep2OutputData->iFrameId, step2ResultData);
|
||
break;
|
||
case K_TRAIN_NUM ... NX_TRAIN_NUM:
|
||
//车号加入待汇总集合中
|
||
this->numAddSelectBestMap(pVStep2OutputData->iFrameId, step2ResultData);
|
||
break;
|
||
case CONTAINERNUM:
|
||
this->containerAddSelectBestMap(pVStep2OutputData->iFrameId, step2ResultData);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
// LogDebug << "-->" << this->partionInfo_.iEndframe << "--" << pVStep2OutputData->iFrameId;
|
||
|
||
if (pVStep2OutputData->iFrameId == this->partionInfo_.iEndframe)
|
||
{
|
||
this->getTrainBest(pVStep2OutputData);
|
||
|
||
this->partionInfo_.iTrainIndex = 0;
|
||
// 当节车厢出现的开始帧帧号
|
||
this->partionInfo_.iStartframe = 0;
|
||
// 当节车厢出现的结束帧帧号
|
||
this->partionInfo_.iEndframe = 0;
|
||
|
||
//初始化参数变量
|
||
InitParam();
|
||
}
|
||
}
|
||
return APP_ERR_OK;
|
||
}
|