generated from zhangwei/Train_Identify
632 lines
24 KiB
C++
632 lines
24 KiB
C++
#include "DataDealTwoEngine.h"
|
||
|
||
using namespace ai_matrix;
|
||
|
||
extern bool g_bNoDealStepTwoFlag;
|
||
|
||
DataDealTwoEngine::DataDealTwoEngine() {}
|
||
|
||
DataDealTwoEngine::~DataDealTwoEngine() {}
|
||
|
||
APP_ERROR DataDealTwoEngine::Init()
|
||
{
|
||
strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
|
||
strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";
|
||
strPort2_ = engineName_ + "_" + std::to_string(engineId_) + "_2";
|
||
strResultPath_ = MyYaml::GetIns()->GetPathValue("gc_result_path");
|
||
iIntervalTime_ = 40 *1000;
|
||
iSplitSpanPX_ = MyYaml::GetIns()->GetIntValue("gc_split_frame_span_px");
|
||
|
||
dataSourceConfig_ = MyYaml::GetIns()->GetDataSourceConfigById(engineId_); //获取摄像机参数
|
||
mapUseDataSouceCfg_ = MyYaml::GetIns()->GetUseDataSourceConfig();
|
||
|
||
std::string delimiter(",");
|
||
for (auto iter = mapUseDataSouceCfg_.begin(); iter!=mapUseDataSouceCfg_.end(); iter++)
|
||
{
|
||
int iSourceId = iter->first;
|
||
std::vector<std::string> vecSplit = MyUtils::getins()->split(iter->second.strTarget, delimiter);
|
||
|
||
std::vector<std::string> vecPushPorts;
|
||
for (auto iter = vecSplit.begin(); iter != vecSplit.end(); iter++)
|
||
{
|
||
if (*iter == "NUM")
|
||
{
|
||
vecPushPorts.push_back(strPort0_);
|
||
}
|
||
else if (*iter == "CHKDATE")
|
||
{
|
||
vecPushPorts.push_back(strPort1_);
|
||
}
|
||
else if(*iter == "CONTAINER" || *iter == "CONTAINER_T")
|
||
{
|
||
vecPushPorts.push_back(strPort2_);
|
||
}
|
||
}
|
||
mapSourcePushPort_[iSourceId] = vecPushPorts;
|
||
}
|
||
|
||
InitParam();
|
||
LogInfo << "engineId_:" << engineId_ << " DataDealTwoEngine Init ok";
|
||
return APP_ERR_OK;
|
||
}
|
||
|
||
APP_ERROR DataDealTwoEngine::DeInit()
|
||
{
|
||
|
||
LogInfo << "engineId_:" << engineId_ << " DataDealTwoEngine DeInit ok";
|
||
return APP_ERR_OK;
|
||
}
|
||
|
||
/**
|
||
* 参数初始化(列车结束时需调用)
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::InitParam()
|
||
{
|
||
iTrainIndex_ = 1;
|
||
iDirection_ = DIRECTION_UNKNOWN;
|
||
iDirectionAndFirst_ = DO_NOT_KNOW_DIRECTION;
|
||
iLastSpaceX_ = 0;
|
||
iLastSpaceFrameid_ = 0;
|
||
iSpaceType_ = 0;
|
||
}
|
||
|
||
/**
|
||
* 图片数据解码
|
||
* inParam : RawData &rawData :图片数据
|
||
* outParam: std::shared_ptr<DecodedData> pDecodedData :解码数据
|
||
* return : true(编码成功)/false(编码失败)
|
||
*/
|
||
bool DataDealTwoEngine::GetJpegdOut(std::shared_ptr<DecodedData> pDecodedData, RawData &rawData)
|
||
{
|
||
int iRet = APP_ERR_OK;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 获取大框信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::GetPostSubDatas(std::vector<PostSubData> &vecPostSubData, Json::Value &jvFrameInfo,
|
||
Target tar, Json::Value &jvOneSplit)
|
||
{
|
||
std::string strKey;
|
||
switch (tar)
|
||
{
|
||
case NUM:
|
||
strKey = "step1Num";
|
||
break;
|
||
case PRO:
|
||
strKey = "step1Pro";
|
||
break;
|
||
case CHKDATE:
|
||
strKey = "step1ChkDate";
|
||
break;
|
||
case CONTAINER:
|
||
strKey = "step1Container";
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (strKey.empty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!jvFrameInfo.isMember(strKey.c_str()))
|
||
{
|
||
return;
|
||
}
|
||
|
||
float fSplitCenterX = jvOneSplit["splitX"].asFloat();
|
||
int iValidType = jvOneSplit["validType"].asInt();
|
||
|
||
Json::Value &jsArray = jvFrameInfo[strKey.c_str()];
|
||
for (int i = 0; i < jsArray.size(); i++)
|
||
{
|
||
float fCenterX = jsArray[i]["ltx"].asFloat() + (jsArray[i]["rbx"].asFloat() - jsArray[i]["ltx"].asFloat()) / 2;
|
||
if (jvOneSplit["useY"].asBool())
|
||
{
|
||
fCenterX = jsArray[i]["lty"].asFloat() + (jsArray[i]["rby"].asFloat() - jsArray[i]["lty"].asFloat()) / 2;
|
||
}
|
||
|
||
bool bChkFlag = false;
|
||
if(iValidType == VALID_ALL)
|
||
{
|
||
bChkFlag = true;
|
||
}
|
||
else if(iValidType == VALID_LEFT && fCenterX < fSplitCenterX)
|
||
{
|
||
bChkFlag = true;
|
||
}
|
||
else if(iValidType == VALID_RIGHT && fCenterX > fSplitCenterX)
|
||
{
|
||
bChkFlag = true;
|
||
}
|
||
|
||
if (bChkFlag)
|
||
{
|
||
SingleData sdInfo;
|
||
sdInfo.iClassId = jsArray[i]["classid"].asInt();
|
||
sdInfo.fScore = jsArray[i]["score"].asFloat();
|
||
sdInfo.fLTX = jsArray[i]["ltx"].asFloat();
|
||
sdInfo.fLTY = jsArray[i]["lty"].asFloat();
|
||
sdInfo.fRBX = jsArray[i]["rbx"].asFloat();
|
||
sdInfo.fRBY = jsArray[i]["rby"].asFloat();
|
||
sdInfo.fClear = jsArray[i]["clear"].asFloat();
|
||
|
||
PostSubData postSubData;
|
||
postSubData.iBigClassId = sdInfo.iClassId;
|
||
postSubData.iTargetType = tar;
|
||
if (tar == NUM && postSubData.iBigClassId == 0)
|
||
{
|
||
postSubData.iTargetType = HEAD;
|
||
}
|
||
postSubData.vecSingleData.emplace_back(sdInfo);
|
||
postSubData.step1Location.fLTX = sdInfo.fLTX;
|
||
postSubData.step1Location.fLTY = sdInfo.fLTY;
|
||
postSubData.step1Location.fRBX = sdInfo.fRBX;
|
||
postSubData.step1Location.fRBY = sdInfo.fRBY;
|
||
vecPostSubData.emplace_back(postSubData);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取主摄像头车厢间隔坐标信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::GetMainSplitInfo(Json::Value &jvMainSplit, std::shared_ptr<ProcessData> pProcessData,
|
||
Json::Value &jvFrameInfo, std::shared_ptr<TrainRange> pTrainRange)
|
||
{
|
||
if (pProcessData->iDataSource != 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Json::Value jvModelSpace;
|
||
if (jvFrameInfo.isMember("step1Space"))
|
||
{
|
||
jvModelSpace = jvFrameInfo["step1Space"][0];
|
||
}
|
||
|
||
int iValidType = VALID_ALL; //图像上大框有效类型 {0-全部有效; 1-左边有效; 2-右边有效}
|
||
int iSpaceX = 0; //图像上车厢间隔位置
|
||
bool bNeedNum = true; //图像上车号框是否有效
|
||
bool bNeedPro = true; //图像上属性框是否有效
|
||
bool bNeedChkDate = true; //图像定检期框是否有效
|
||
bool bNeedContainer = true; //图像集装箱框是否有效
|
||
bool bOtherSideNeedNum = true; //另一侧图像上车号框是否有效
|
||
bool bOtherSideNeedPro = true; //另一侧图像上属性框是否有效
|
||
bool bOtherSideNeedChkDate = true; //另一侧图像上定检期框是否有效
|
||
bool bOtherSideNeedContainer = true; //另一侧图像上集装箱框是否有效
|
||
|
||
if (!jvModelSpace.empty())
|
||
{
|
||
iSpaceX = jvModelSpace["ltx"].asFloat() + (jvModelSpace["rbx"].asFloat() - jvModelSpace["ltx"].asFloat()) / 2;
|
||
/*
|
||
第一节只有结束间隔;
|
||
开始帧间隔为开始间隔;
|
||
向左行驶且当前间隔大于上次间隔为结束间隔，向右行驶当前间隔小于上次间隔为结束间隔。
|
||
*/
|
||
bool bIntervalFlag = ((int)(pProcessData->iFrameId - iLastSpaceFrameid_) > dataSourceConfig_.iSkipInterval * 2);
|
||
if (iTrainIndex_ == 1)
|
||
{
|
||
iSpaceType_ = 2;
|
||
}
|
||
else if (pTrainRange->iStartFrameId == pProcessData->iFrameId)
|
||
{
|
||
iSpaceType_ = 1;
|
||
}
|
||
else if ((pProcessData->iDirection == DIRECTION_LEFT && (iLastSpaceX_ < iSpaceX - iSplitSpanPX_) && bIntervalFlag) ||
|
||
(pProcessData->iDirection == DIRECTION_RIGHT && (iLastSpaceX_ - iSplitSpanPX_ > iSpaceX) && bIntervalFlag))
|
||
{
|
||
iSpaceType_ = 2;
|
||
}
|
||
|
||
if (iSpaceType_ == 1)
|
||
{
|
||
iValidType = pProcessData->iDirection == DIRECTION_LEFT ? VALID_RIGHT : VALID_LEFT;
|
||
}
|
||
else if (iSpaceType_ == 2)
|
||
{
|
||
iValidType = pProcessData->iDirection == DIRECTION_LEFT ? VALID_LEFT : VALID_RIGHT;
|
||
}
|
||
LogDebug << " frameid:" << pProcessData->iFrameId
|
||
<< " 车节:" << pProcessData->iTrainIndex << " iSpaceType_:" << iSpaceType_
|
||
<< " iSpaceX:" << iSpaceX << " iLastSpaceX_:" << iLastSpaceX_
|
||
<< " iLastSpaceFrameid_:" << iLastSpaceFrameid_ << " bIntervalFlag:" << bIntervalFlag;
|
||
iLastSpaceX_ = iSpaceX;
|
||
iLastSpaceFrameid_ = pProcessData->iFrameId;
|
||
}
|
||
|
||
jvMainSplit["validType"] = iValidType;
|
||
jvMainSplit["splitX"] = iSpaceX;
|
||
jvMainSplit["needNum"] = bNeedNum;
|
||
jvMainSplit["needPro"] = bNeedPro;
|
||
jvMainSplit["needChkDate"] = bNeedChkDate;
|
||
jvMainSplit["needContainer"] = bNeedContainer;
|
||
jvMainSplit["otherSideNeedNum"] = bOtherSideNeedNum;
|
||
jvMainSplit["otherSideNeedPro"] = bOtherSideNeedPro;
|
||
jvMainSplit["otherSideNeedChkDate"] = bOtherSideNeedChkDate;
|
||
jvMainSplit["otherSideNeedContainer"] = bOtherSideNeedContainer;
|
||
jvMainSplit["mainWidth"] = pProcessData->iWidth;
|
||
jvMainSplit["mainHeight"] = pProcessData->iHeight;
|
||
|
||
if (pProcessData->bIsEnd)
|
||
{
|
||
iLastSpaceX_ = 0;
|
||
iLastSpaceFrameid_ = 0;
|
||
iSpaceType_ = 0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取辅摄像头车厢间隔坐标信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::GetSubSplitInfoByMain(Json::Value &jvOneSplit, std::shared_ptr<ProcessData> pProcessData, Json::Value &jvFrameInfo)
|
||
{
|
||
if (pProcessData->iDataSource == 1)
|
||
{
|
||
if (pProcessData->iDirection == DIRECTION_RIGHT)
|
||
{
|
||
//向右行驶时，间隔坐标尽可能小一些，把未完全对其的定检期信息包含进来。
|
||
jvOneSplit["splitX"] = jvOneSplit["splitX"].asInt() - 100;
|
||
}
|
||
}
|
||
else if (pProcessData->iDataSource == 2)
|
||
{
|
||
//顶部集装箱的重设splitX相关逻辑
|
||
if (jvOneSplit["rotate"].asInt() == 90)
|
||
{
|
||
jvOneSplit["useY"] = true;
|
||
if (pProcessData->iHeight != jvOneSplit["mainWidth"].asInt())
|
||
{
|
||
jvOneSplit["splitX"] = jvOneSplit["splitX"].asInt() * pProcessData->iHeight / jvOneSplit["mainWidth"].asInt();
|
||
}
|
||
|
||
//顶部有间隔时，使用顶部间隔。
|
||
if (jvFrameInfo.isMember("step1TopSpace"))
|
||
{
|
||
Json::Value jvModelSpace = jvFrameInfo["step1TopSpace"][0];
|
||
int iSpaceX = jvModelSpace["lty"].asFloat() + (jvModelSpace["rby"].asFloat() - jvModelSpace["lty"].asFloat()) / 2;
|
||
LogDebug << "sourceid" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId << " use TopSpace splitX:"
|
||
<< jvOneSplit["splitX"].asInt() << " newsplitX:" << iSpaceX;
|
||
jvOneSplit["splitX"] = iSpaceX;
|
||
|
||
//如果validType为0，则说明主摄像头间隔还未识别到结束间隔，则按顶部摄像头设置validType
|
||
if (jvOneSplit["validType"] == VALID_ALL)
|
||
{
|
||
jvOneSplit["validType"] = pProcessData->iDirection == DIRECTION_LEFT ? VALID_LEFT : VALID_RIGHT;
|
||
LogDebug << "sourceid" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId
|
||
<< "reset validType:" << jvOneSplit["validType"].asInt();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (pProcessData->iDataSource == 3 || pProcessData->iDataSource == 4)
|
||
{
|
||
jvOneSplit["splitX"] = (int)(pProcessData->iWidth - jvOneSplit["splitX"].asInt());
|
||
int iValidType = jvOneSplit["validType"].asInt();
|
||
iValidType = iValidType == VALID_ALL ? iValidType : (iValidType == VALID_LEFT ? VALID_RIGHT : VALID_LEFT);
|
||
jvOneSplit["validType"] = iValidType;
|
||
jvOneSplit["needNum"] = jvOneSplit["otherSideNeedNum"].asBool();
|
||
jvOneSplit["needPro"] = jvOneSplit["otherSideNeedPro"].asBool();
|
||
jvOneSplit["needChkDate"] = jvOneSplit["otherSideNeedChkDate"].asBool();
|
||
jvOneSplit["needContainer"] = jvOneSplit["otherSideNeedContainer"].asBool();
|
||
|
||
if (pProcessData->iDataSource == 4 && pProcessData->iDirection == DIRECTION_LEFT)
|
||
{
|
||
jvOneSplit["splitX"] = jvOneSplit["splitX"].asInt() + 100;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取大框有效方式和车厢间隔坐标
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::GetValidTypeAndSplit(Json::Value &jvOneSplit, Json::Value &jvMainSplit,
|
||
std::shared_ptr<ProcessData> pProcessData, Json::Value &jvFrameInfo,
|
||
std::shared_ptr<TrainRange> pTrainRange)
|
||
{
|
||
if (pProcessData->iDataSource == 0)
|
||
{
|
||
GetMainSplitInfo(jvMainSplit, pProcessData, jvFrameInfo, pTrainRange);
|
||
jvOneSplit = jvMainSplit;
|
||
}
|
||
else
|
||
{
|
||
GetSubSplitInfoByMain(jvOneSplit, pProcessData, jvFrameInfo);
|
||
}
|
||
|
||
// LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId
|
||
// << " trainIndex:" << pProcessData->iTrainIndex
|
||
// << " validType:" << jvOneSplit["validType"].asInt() << " splitX:" << jvOneSplit["splitX"].asInt()
|
||
// << " needNum:" << jvOneSplit["needNum"].asBool() << " needPro:" << jvOneSplit["needPro"].asBool()
|
||
// << " needChkDate:" << jvOneSplit["needChkDate"].asBool() << " needContainer:" << jvOneSplit["needContainer"].asBool();
|
||
}
|
||
|
||
/**
|
||
* 获取大框信息
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
int DataDealTwoEngine::GetPostData(std::shared_ptr<ProcessData> pProcessData, Json::Value &jvFrameInfo, Json::Value &jvOneSplit)
|
||
{
|
||
std::shared_ptr<PostData> pPostData = std::make_shared<PostData>();
|
||
pProcessData->pVoidData = std::static_pointer_cast<void>(pPostData);
|
||
|
||
if (jvOneSplit["needNum"].asBool())
|
||
{
|
||
GetPostSubDatas(pPostData->vecPostSubData, jvFrameInfo, NUM, jvOneSplit);
|
||
}
|
||
|
||
if (jvOneSplit["needPro"].asBool())
|
||
{
|
||
GetPostSubDatas(pPostData->vecPostSubData, jvFrameInfo, PRO, jvOneSplit);
|
||
}
|
||
|
||
if (jvOneSplit["needChkDate"].asBool())
|
||
{
|
||
/*
|
||
向右行驶且间隔右边数据有效时，此时画面就1个定检期，画面上的定检期信息全部有效。
|
||
向左行驶且间隔左边数据有效时，此时画面就1个定检期，画面上的定检期信息全部有效。
|
||
*/
|
||
int iValidTypeTemp = jvOneSplit["validType"].asInt();
|
||
|
||
if ((iValidTypeTemp == VALID_RIGHT && pProcessData->iDataSource == 1 && pProcessData->iDirection == DIRECTION_RIGHT) ||
|
||
(iValidTypeTemp == VALID_RIGHT && pProcessData->iDataSource == 4 && pProcessData->iDirection == DIRECTION_LEFT) ||
|
||
(iValidTypeTemp == VALID_LEFT && pProcessData->iDataSource == 1 && pProcessData->iDirection == DIRECTION_LEFT) ||
|
||
(iValidTypeTemp == VALID_LEFT && pProcessData->iDataSource == 4 && pProcessData->iDirection == DIRECTION_RIGHT))
|
||
{
|
||
jvOneSplit["validType"] = 0;
|
||
}
|
||
GetPostSubDatas(pPostData->vecPostSubData, jvFrameInfo, CHKDATE, jvOneSplit);
|
||
jvOneSplit["validType"] = iValidTypeTemp;
|
||
}
|
||
|
||
if (jvOneSplit["needContainer"].asBool())
|
||
{
|
||
GetPostSubDatas(pPostData->vecPostSubData, jvFrameInfo, CONTAINER, jvOneSplit);
|
||
}
|
||
|
||
return pPostData->vecPostSubData.size();
|
||
}
|
||
|
||
/**
|
||
* push数据到队列，队列满时则休眠一段时间再push。
|
||
* inParam : const std::string strPort push的端口
|
||
: const std::shared_ptr<ProcessData> &pProcessData push的数据
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::PushData(const std::string &strPort, const std::shared_ptr<ProcessData> &pProcessData)
|
||
{
|
||
while (true)
|
||
{
|
||
int iRet = outputQueMap_[strPort]->push(std::static_pointer_cast<void>(pProcessData));
|
||
if (iRet != 0)
|
||
{
|
||
LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId << " push fail iRet:" << iRet;
|
||
if (iRet == 2)
|
||
{
|
||
usleep(10000); // 10ms
|
||
continue;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 构造处理数据并push
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : N/A
|
||
*/
|
||
void DataDealTwoEngine::MakeProcessData(std::shared_ptr<TrainRange> pTrainRange)
|
||
{
|
||
int iRet = APP_ERR_OK;
|
||
int iDataNO = 1;
|
||
|
||
std::string strDataDir = strResultPath_ + pTrainRange->strTrainDate + "/" + pTrainRange->strTrainName + "/";
|
||
for (int iFrameId = pTrainRange->iStartFrameId; iFrameId <= pTrainRange->iEndFrameId; iFrameId += dataSourceConfig_.iSkipInterval)
|
||
{
|
||
Json::Value jvMainSplit; //主摄像头车厢间隔坐标信息
|
||
int iStatus = TRAINSTATUS_RUN;
|
||
int iTagTotalCnt = 0;
|
||
for (auto iter = mapUseDataSouceCfg_.begin(); iter != mapUseDataSouceCfg_.end(); iter++)
|
||
{
|
||
int iSourceId = iter->first;
|
||
char szCameraNo[5] = {0};
|
||
sprintf(szCameraNo, "%03d/", iSourceId + 1);
|
||
bool bIsEndFlag = (pTrainRange->iEndFrameId == iFrameId);
|
||
|
||
// LogInfo << "sourceid:" << iSourceId << " StepTwo MakeProcessData trainIndex:" << pTrainRange->iTrainIndex
|
||
// << " iFrameId:" << iFrameId << " bIsEndFlag:" << bIsEndFlag;
|
||
std::string strImgName = strDataDir + szCameraNo + std::to_string(iFrameId);
|
||
strImgName += (iter->second.iRotate != 0) ? "_rotate.jpg" : ".jpg";
|
||
std::string strFileName = strDataDir + szCameraNo + std::to_string(iFrameId) + ".txt";
|
||
|
||
// 获取大框信息
|
||
Json::Value jvFrameInfo;
|
||
bool bReadFlag = MyUtils::getins()->ReadJsonInfo(jvFrameInfo, strFileName, 0);
|
||
if (!bIsEndFlag && !bReadFlag)
|
||
{
|
||
//非车厢结束帧且没有txt信息时不处理。
|
||
continue;
|
||
}
|
||
|
||
iStatus = (iSourceId == 0 ? jvFrameInfo["status"].asInt() : iStatus);
|
||
|
||
// 构造处理数据信息
|
||
std::shared_ptr<ProcessData> pProcessData = std::make_shared<ProcessData>();
|
||
pProcessData->iDataSource = iSourceId;
|
||
pProcessData->iFrameId = iFrameId;
|
||
pProcessData->strTrainDate = pTrainRange->strTrainDate;
|
||
pProcessData->strTrainName = pTrainRange->strTrainName;
|
||
pProcessData->bIsEnd = bIsEndFlag;
|
||
pProcessData->iStatus = iStatus;
|
||
pProcessData->iDirection = iDirection_;
|
||
pProcessData->iDataNO = iDataNO;
|
||
pProcessData->iTrainIndex = pTrainRange->iTrainIndex;
|
||
pProcessData->bIsTrainEnd = pTrainRange->bIsEnd;
|
||
pProcessData->strPicFilePath = strImgName;
|
||
pProcessData->i64TimeStamp = jvFrameInfo["timeStamp"].asUInt64();
|
||
pProcessData->iWidth = jvFrameInfo["width"].asInt();
|
||
pProcessData->iHeight = jvFrameInfo["height"].asInt();
|
||
|
||
Json::Value jvOneSplit;
|
||
jvOneSplit = jvMainSplit;
|
||
jvOneSplit["rotate"] = iter->second.iRotate;
|
||
GetValidTypeAndSplit(jvOneSplit, jvMainSplit, pProcessData, jvFrameInfo, pTrainRange);
|
||
|
||
// 获取有效的大框信息
|
||
int iRetCnt = GetPostData(pProcessData, jvFrameInfo, jvOneSplit);
|
||
iTagTotalCnt += iRetCnt;
|
||
|
||
if (iRetCnt > 0 && iStatus == TRAINSTATUS_RUN)
|
||
{
|
||
cv::Mat cvframe = cv::imread(pProcessData->strPicFilePath);
|
||
int iBufferSize = pProcessData->iWidth * pProcessData->iHeight * 3;
|
||
void *pBGRBufferobj = nullptr;
|
||
pBGRBufferobj = new uint8_t[iBufferSize];
|
||
memcpy(pBGRBufferobj, cvframe.data, iBufferSize);
|
||
pProcessData->pData.reset(pBGRBufferobj, [](void *data){if(data) {delete[] data; data = nullptr;}});
|
||
pProcessData->iSize = iBufferSize;
|
||
}
|
||
|
||
std::vector<std::string> vecPushPorts = mapSourcePushPort_[iSourceId];
|
||
for (int iPort = 0; iPort < vecPushPorts.size(); iPort++)
|
||
{
|
||
if (iPort == vecPushPorts.size() - 1)
|
||
{
|
||
//iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pProcessData), true);
|
||
PushData(vecPushPorts[iPort], pProcessData);
|
||
continue;
|
||
}
|
||
std::shared_ptr<ProcessData> pNewProcessData = std::make_shared<ProcessData>();
|
||
*pNewProcessData = *pProcessData;
|
||
//iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pNewProcessData), true);
|
||
PushData(vecPushPorts[iPort], pNewProcessData);
|
||
}
|
||
}
|
||
|
||
iDataNO++;
|
||
//每组处理数据需间隔一定时间 (运行状态且有第一步结果需休眠，否则直接处理后面的数据)
|
||
if (iStatus == TRAINSTATUS_RUN && iTagTotalCnt != 0)
|
||
{
|
||
usleep(iIntervalTime_);
|
||
}
|
||
while (g_bNoDealStepTwoFlag)
|
||
{
|
||
usleep(iIntervalTime_);
|
||
}
|
||
}
|
||
}
|
||
|
||
APP_ERROR DataDealTwoEngine::Process()
|
||
{
|
||
int iRet = APP_ERR_OK;
|
||
while (!isStop_)
|
||
{
|
||
//获取主摄像头车厢划分结果
|
||
std::shared_ptr<void> pVoidData0 = nullptr;
|
||
iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
|
||
if (nullptr == pVoidData0)
|
||
{
|
||
usleep(1000); // 1ms
|
||
continue;
|
||
}
|
||
|
||
std::shared_ptr<TrainRange> pTrainRange = std::static_pointer_cast<TrainRange>(pVoidData0);
|
||
LogInfo << "step2 start traindate:" << pTrainRange->strTrainDate << " trainname:" << pTrainRange->strTrainName
|
||
<< " trainindex:" << pTrainRange->iTrainIndex << " startframeid:" << pTrainRange->iStartFrameId
|
||
<< " endframeid:" << pTrainRange->iEndFrameId << " isEnd:" << pTrainRange->bIsEnd;
|
||
|
||
if (iDirection_ == DIRECTION_UNKNOWN)
|
||
{
|
||
/*获取该车辆行驶方向
|
||
特殊场景：车头行驶画面一半后停止，再次反方向驶出画面。再次行驶得场景不会有方向.(因没有大框无法计算方向)
|
||
*/
|
||
std::string strFilePath = strResultPath_ + pTrainRange->strTrainDate + "/" + pTrainRange->strTrainName + "/" + "direction.txt";
|
||
int iCnt = 0;
|
||
while (!isStop_ && iCnt < 10)
|
||
{
|
||
Json::Value jvDirectionInfo;
|
||
if (MyUtils::getins()->ReadJsonInfo(jvDirectionInfo, strFilePath))
|
||
{
|
||
iDirection_ = jvDirectionInfo["direction"].asInt();
|
||
//按行驶方向获取车号在前还是属性在前
|
||
if (iDirectionAndFirst_ == DO_NOT_KNOW_DIRECTION && iDirection_ != DIRECTION_UNKNOWN)
|
||
{
|
||
iDirectionAndFirst_ = iDirection_ == DIRECTION_LEFT ? dataSourceConfig_.iLeftFirst : dataSourceConfig_.iRightFirst;
|
||
}
|
||
break;
|
||
}
|
||
usleep(500 * 1000); // 500ms
|
||
iCnt++;
|
||
}
|
||
}
|
||
|
||
/*重置开始帧，结束帧
|
||
开始帧向上取跳帧的倍数，结束帧向下取跳帧的倍数
|
||
例: 车厢开始帧结束帧[50, 125]，则推理的开始帧结束帧为[52, 124]
|
||
*/
|
||
int iSkipInterval = dataSourceConfig_.iSkipInterval;
|
||
pTrainRange->iStartFrameId = (pTrainRange->iStartFrameId + iSkipInterval - 1) / iSkipInterval * iSkipInterval;
|
||
pTrainRange->iEndFrameId = pTrainRange->iEndFrameId / iSkipInterval * iSkipInterval;
|
||
if (pTrainRange->iStartFrameId > pTrainRange->iEndFrameId)
|
||
{
|
||
pTrainRange->iStartFrameId = pTrainRange->iEndFrameId;
|
||
}
|
||
|
||
//判断第一步是否处理完毕
|
||
char szCameraNo[5] = {0};
|
||
sprintf(szCameraNo, "%03d/", engineId_ + 1);
|
||
std::string strFilePath = strResultPath_ + pTrainRange->strTrainDate + "/" + pTrainRange->strTrainName + "/" +
|
||
szCameraNo + std::to_string(pTrainRange->iEndFrameId) + ".txt";
|
||
|
||
int iReadCnt = 0;
|
||
bool bRet = false;
|
||
while (!isStop_ && iReadCnt < 30)
|
||
{
|
||
Json::Value jvFrameInfo;
|
||
bRet = MyUtils::getins()->ReadJsonInfo(jvFrameInfo, strFilePath);
|
||
if (jvFrameInfo["step1Finish"].asBool())
|
||
{
|
||
break;
|
||
}
|
||
usleep(500 * 1000); // 500ms
|
||
iReadCnt++;
|
||
}
|
||
|
||
//处理当车厢的每帧信息
|
||
MakeProcessData(pTrainRange);
|
||
// push结果汇总
|
||
iRet = outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_9"]->push(std::static_pointer_cast<void>(pTrainRange));
|
||
|
||
iTrainIndex_++;
|
||
if (pTrainRange->bIsEnd)
|
||
{
|
||
InitParam();
|
||
}
|
||
}
|
||
|
||
return APP_ERR_OK;
|
||
}
|