|
|
#include "QX_Merge_Analysis.h"
|
|
|
#include <memory>
|
|
|
#include <string>
|
|
|
#include <mutex>
|
|
|
#include <thread>
|
|
|
#include <chrono>
|
|
|
#include "CheckUtil.hpp"
|
|
|
#include "CheckConfigDefine.h"
|
|
|
|
|
|
QX_Merge_Analysis::QX_Merge_Analysis()
|
|
|
{
|
|
|
m_bExit = false;
|
|
|
Clear();
|
|
|
StartThread(0);
|
|
|
}
|
|
|
|
|
|
QX_Merge_Analysis::~QX_Merge_Analysis()
|
|
|
{
|
|
|
StopThread();
|
|
|
}
|
|
|
|
|
|
std::shared_ptr<QX_Merge_Analysis> QX_Merge_Analysis::GetInstance()
|
|
|
{
|
|
|
std::shared_ptr<QX_Merge_Analysis> instance = std::make_shared<QX_Merge_Analysis>();
|
|
|
return instance;
|
|
|
}
|
|
|
int QX_Merge_Analysis::Clear()
|
|
|
{
|
|
|
m_pdetlogList.clear();
|
|
|
m_statusList.clear();
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
int QX_Merge_Analysis::AddCamer(std::string cameraName)
|
|
|
{
|
|
|
setSendStatus(cameraName, RUN_STATUS_NULL);
|
|
|
for (auto &it : m_statusList)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "AddCamer %s %d", it.first.c_str(), it.second);
|
|
|
}
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "AddCamer %s %s", cameraName.c_str(),CheckUtil::getCurTimeHMS().c_str());
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
int QX_Merge_Analysis::InitData()
|
|
|
{
|
|
|
m_reultList.Init();
|
|
|
m_pMergedetlog = std::make_shared<DetLog>();
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "InitData %s",CheckUtil::getCurTimeHMS().c_str());
|
|
|
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_QXList);
|
|
|
for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
|
|
|
{
|
|
|
m_QXList[i].Init();
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::GetReusult(QX_Analysis_Result_List *&presult)
|
|
|
{
|
|
|
presult = &m_reultList;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void QX_Merge_Analysis::SetConfig(std::string cameraName, int qxidx,
|
|
|
QXAnalysis_Config config)
|
|
|
{
|
|
|
if (cameraName == "")
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
|
|
|
ALL_QX_ParamList *pqxConfigList = nullptr;
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_ConfigList); //
|
|
|
pqxConfigList = &m_ConfigList[qxidx];
|
|
|
pqxConfigList->configlsit.push_back(config);
|
|
|
}
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "SetConfig cameraName %s qxidx %d ", cameraName.c_str(), qxidx);
|
|
|
}
|
|
|
|
|
|
void QX_Merge_Analysis::InitConfig(std::string cameraName)
|
|
|
{
|
|
|
// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_ConfigList);
|
|
|
for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
|
|
|
{
|
|
|
m_ConfigList[i].Init();
|
|
|
}
|
|
|
}
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "InitConfig cameraName %s ", cameraName.c_str());
|
|
|
}
|
|
|
|
|
|
void QX_Merge_Analysis::SetbaseCheckFunction(std::string cameraName, ALLChannelCheckFunction *pChannelFuntion, BaseCheckFunction *pbaseCheckFunction)
|
|
|
{
|
|
|
if (cameraName == "")
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
m_pChannelFuntion = pChannelFuntion;
|
|
|
m_pbaseCheckFunction = pbaseCheckFunction;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::ConfigTypeToQXAnalysis(int nconfigType)
|
|
|
{
|
|
|
int QXAnalysis_type = -1;
|
|
|
switch (nconfigType)
|
|
|
{
|
|
|
case CONFIG_QX_NAME_POL_Cell:
|
|
|
QXAnalysis_type = QX_ANALYSIS_POL_CELL; // 异物
|
|
|
break;
|
|
|
case CONFIG_QX_NAME_AD:
|
|
|
QXAnalysis_type = QX_ANALYSIS_AD; // 暗点
|
|
|
break;
|
|
|
case CONFIG_QX_NAME_Scratch_L1:
|
|
|
case CONFIG_QX_NAME_Scratch_L2:
|
|
|
QXAnalysis_type = QX_ANALYSIS_Scratch; // 划伤
|
|
|
break;
|
|
|
case CONFIG_QX_NAME_X_line:
|
|
|
case CONFIG_QX_NAME_Y_line:
|
|
|
case CONFIG_QX_NAME_line:
|
|
|
case CONFIG_QX_NAME_Fangge:
|
|
|
QXAnalysis_type = QX_ANALYSIS_LINE; // 线类
|
|
|
break;
|
|
|
case CONFIG_QX_NAME_MTX:
|
|
|
QXAnalysis_type = QX_ANALYSIS_MTX; // MTX
|
|
|
break;
|
|
|
// case CONFIG_QX_NAME_Broken_line:
|
|
|
// QXAnalysis_type = QX_ANALYSIS_ALL, // MTX&异物
|
|
|
// break;
|
|
|
|
|
|
default:
|
|
|
QXAnalysis_type = -1;
|
|
|
break;
|
|
|
}
|
|
|
return QXAnalysis_type;
|
|
|
}
|
|
|
bool QX_Merge_Analysis::Idx(int qxidx)
|
|
|
{
|
|
|
if (qxidx < 0 || qxidx >= QX_ANALYSIS_COUNT)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
bool QX_Merge_Analysis::AddQxInfo(int qxidx, QX_Info qxinfo, std::shared_ptr<DetLog> plog, std::shared_ptr<DetLog> pchannelLog)
|
|
|
{
|
|
|
std::string channel_name = qxinfo.channel_name;
|
|
|
std::string cam_name = qxinfo.camera_name;
|
|
|
ALL_QX_ParamList *pconfigList = nullptr;
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_ConfigList);
|
|
|
pconfigList = &m_ConfigList[qxidx];
|
|
|
}
|
|
|
|
|
|
if (pconfigList == nullptr)
|
|
|
{
|
|
|
plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "cam_name = %s config error",
|
|
|
cam_name.c_str());
|
|
|
return false;
|
|
|
}
|
|
|
if (!Idx(qxidx))
|
|
|
{
|
|
|
plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "qxidx error");
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 初步筛选一次
|
|
|
bool badd = false;
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_ConfigList);
|
|
|
for (int i = 0; i < (int)pconfigList->configlsit.size(); i++)
|
|
|
{
|
|
|
QXAnalysis_Config *pconfig = &pconfigList->configlsit.at(i);
|
|
|
// 面积 灰阶满足要求
|
|
|
if (qxinfo.area >= pconfig->area &&
|
|
|
qxinfo.hj >= pconfig->hj &&
|
|
|
qxinfo.length >= pconfig->len &&
|
|
|
qxinfo.density >= pconfig->density)
|
|
|
{
|
|
|
badd = true;
|
|
|
}
|
|
|
plog->AddCheckstr(PrintLevel_3, 3, "preA", "add = %s congfig idx %d / %d ", BOOL_TO_STR(badd), i, (int)pconfigList->configlsit.size());
|
|
|
plog->AddCheckstr(PrintLevel_4, 3, "Area", "%s -> %f %s %f ",
|
|
|
BOOL_TO_STR(qxinfo.area >= pconfig->area), qxinfo.area, BOOL_TO_ThanLess(qxinfo.area >= pconfig->area), pconfig->area);
|
|
|
plog->AddCheckstr(PrintLevel_4, 3, "HJ", "%s -> %f %s %d ",
|
|
|
BOOL_TO_STR(qxinfo.hj >= pconfig->hj), qxinfo.hj, BOOL_TO_ThanLess(qxinfo.hj >= pconfig->hj), pconfig->hj);
|
|
|
plog->AddCheckstr(PrintLevel_4, 3, "Len", "%s -> %f %s %f ",
|
|
|
BOOL_TO_STR(qxinfo.length >= pconfig->len), qxinfo.length, BOOL_TO_ThanLess(qxinfo.length >= pconfig->len), pconfig->len);
|
|
|
plog->AddCheckstr(PrintLevel_4, 3, "md", "%s -> %f %s %f ",
|
|
|
BOOL_TO_STR(qxinfo.density >= pconfig->density), qxinfo.density, BOOL_TO_ThanLess(qxinfo.density >= pconfig->density), pconfig->density);
|
|
|
|
|
|
if (badd)
|
|
|
{
|
|
|
break;
|
|
|
/* code */
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_QXList);
|
|
|
|
|
|
if (badd)
|
|
|
{
|
|
|
QX_channel_List *pQXChannelList = nullptr;
|
|
|
for (auto &config : m_QXList[qxidx].channelqxList)
|
|
|
{
|
|
|
if (config.channel_name == channel_name)
|
|
|
{
|
|
|
pQXChannelList = &config;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (pQXChannelList == nullptr)
|
|
|
{
|
|
|
plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "new channel_name %s ", channel_name.c_str());
|
|
|
QX_channel_List tempchannel;
|
|
|
tempchannel.channel_name = channel_name;
|
|
|
tempchannel.pChannelDetlog = pchannelLog;
|
|
|
tempchannel.qxList.push_back(qxinfo);
|
|
|
|
|
|
m_QXList[qxidx].channelqxList.push_back(tempchannel);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "have channel_name %s ", channel_name.c_str());
|
|
|
pQXChannelList->pChannelDetlog2 = pchannelLog;
|
|
|
pQXChannelList->qxList.push_back(qxinfo);
|
|
|
}
|
|
|
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "m_QXList[%d].channelqxList.size() = %d cam %s channel %s %s",
|
|
|
qxidx, (int)m_QXList[qxidx].channelqxList.size(), cam_name.c_str(), channel_name.c_str(), CheckUtil::getCurTimeHMS().c_str());
|
|
|
}
|
|
|
}
|
|
|
return badd;
|
|
|
}
|
|
|
|
|
|
bool QX_Merge_Analysis::setSendStatus(std::string cameraName, RUN_STATUS_ status)
|
|
|
{
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_status);
|
|
|
m_statusList[cameraName] = status;
|
|
|
}
|
|
|
cv_status.notify_all();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @brief 等待所有任务完成
|
|
|
* @param timeoutMs 超时时间（毫秒）
|
|
|
* @return bool 如果所有任务在超时前完成返回true，否则返回false
|
|
|
*/
|
|
|
bool QX_Merge_Analysis::waitComplete(int timeoutMs)
|
|
|
{
|
|
|
// 使用互斥锁保护共享资源m_statusList
|
|
|
std::unique_lock<std::mutex> lock(mtx_status);
|
|
|
// 记录开始时间
|
|
|
auto startTime = std::chrono::steady_clock::now();
|
|
|
// 循环检查直到所有任务完成或超时或退出标志被设置
|
|
|
while (!m_bExit)
|
|
|
{
|
|
|
// 假设所有任务已完成
|
|
|
bool allComplete = !m_statusList.empty();
|
|
|
// 遍历状态列表检查每个任务的状态
|
|
|
for (auto &it : m_statusList)
|
|
|
{
|
|
|
// 如果发现未完成的任务，设置allComplete为false并跳出循环
|
|
|
if (it.second != RUN_STATUS_COMPLETE)
|
|
|
{
|
|
|
allComplete = false;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
// 如果所有任务都已完成，返回true
|
|
|
if (allComplete)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
|
std::chrono::steady_clock::now() - startTime)
|
|
|
.count();
|
|
|
if (elapsedMs >= timeoutMs)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
cv_status.wait_for(lock, std::chrono::milliseconds(100));
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Run(int nId)
|
|
|
{
|
|
|
std::unique_lock<std::mutex> lock(mtx_status);
|
|
|
|
|
|
while (!m_bExit)
|
|
|
{
|
|
|
cv_status.wait(lock, [this]()
|
|
|
{
|
|
|
if (m_bExit)
|
|
|
return true;
|
|
|
if (m_statusList.empty())
|
|
|
return false;
|
|
|
for (auto &it : m_statusList)
|
|
|
{
|
|
|
if (it.second != RUN_STATUS_READY)
|
|
|
return false;
|
|
|
}
|
|
|
return true; });
|
|
|
|
|
|
if (m_bExit)
|
|
|
break;
|
|
|
|
|
|
if (!m_statusList.empty())
|
|
|
{
|
|
|
|
|
|
for (auto &it : m_statusList)
|
|
|
{
|
|
|
|
|
|
it.second = RUN_STATUS_BUSY;
|
|
|
}
|
|
|
|
|
|
lock.unlock();
|
|
|
|
|
|
StartAnalysis();
|
|
|
lock.lock();
|
|
|
|
|
|
for (auto &it : m_statusList)
|
|
|
{
|
|
|
it.second = RUN_STATUS_COMPLETE;
|
|
|
}
|
|
|
cv_status.notify_all();
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::StartThread(int nId)
|
|
|
{
|
|
|
// 开启检测线程
|
|
|
ptr_thread_Run = std::make_shared<std::thread>(std::bind(&QX_Merge_Analysis::Run, this, nId));
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::StopThread()
|
|
|
{
|
|
|
m_bExit = true;
|
|
|
cv_status.notify_all();
|
|
|
if (ptr_thread_Run != nullptr)
|
|
|
{
|
|
|
if (ptr_thread_Run->joinable())
|
|
|
{
|
|
|
ptr_thread_Run->join();
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::StartAnalysis()
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "==========Start========%s", CheckUtil::getCurTimeHMS().c_str());
|
|
|
// 分析每一个缺陷类型
|
|
|
for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
|
|
|
{
|
|
|
if (QX_ANALYSIS_POL_CELL != i && QX_ANALYSIS_AD != i && QX_ANALYSIS_MTX != i && QX_ANALYSIS_Scratch != i && QX_ANALYSIS_LINE != i)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "== %d 11", i);
|
|
|
continue;
|
|
|
}
|
|
|
if (m_QXList[i].channelqxList.size() <= 0 || m_ConfigList[i].configlsit.size() <= 0)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "== %d channelqxList %ld configlsit %ld",
|
|
|
i, m_QXList[i].channelqxList.size(), m_ConfigList[i].configlsit.size());
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "%s start", QX_ANALYSIS_NAME_Names[i].c_str());
|
|
|
Analysis_QXtype(&m_QXList[i], i);
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "%s end", QX_ANALYSIS_NAME_Names[i].c_str());
|
|
|
}
|
|
|
|
|
|
// presult = &m_reultList;
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Analysis_single_Config(QXAnalysis_Config *pconfig, QX_channel_List *pqxList, int qx_type, std::shared_ptr<DetLog> pchannelLog)
|
|
|
{
|
|
|
pchannelLog->AddCheckstr(PrintLevel_2, 3, "param",
|
|
|
" okparam = %d area %f max_area %f hj %d num %d dis %f len %f md %f",
|
|
|
pconfig->bok, pconfig->area, pconfig->sum_area, pconfig->hj, pconfig->num, pconfig->dis, pconfig->len, pconfig->density);
|
|
|
|
|
|
float sumarea = 0;
|
|
|
float fmaxarea = 0;
|
|
|
int num = 0;
|
|
|
// 遍历每一个相机
|
|
|
Pre_Analysisy_Param param;
|
|
|
param.fAreaMin = pconfig->area;
|
|
|
param.fHJMin = pconfig->hj;
|
|
|
param.fLenMin = pconfig->len;
|
|
|
param.fMdMin = pconfig->density;
|
|
|
|
|
|
pqxList->Initstatus();
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
std::string str = "";
|
|
|
// 面积 灰阶满足要求
|
|
|
if (pqxList->preDet(i, param, str))
|
|
|
{
|
|
|
num++;
|
|
|
pqxList->qxList.at(i).nstatus = 1;
|
|
|
sumarea += pqxList->qxList.at(i).area;
|
|
|
if (pqxList->qxList.at(i).area > fmaxarea)
|
|
|
{
|
|
|
fmaxarea = pqxList->qxList.at(i).area;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
pchannelLog->AddCheckstr(PrintLevel_3, 3, "preA", "qx_idx %d : %s count = %d; %s ",
|
|
|
i, Re_TO_STR_Pass_1(pqxList->qxList.at(i).nstatus), num,
|
|
|
pqxList->qxList.at(i).GetInfo().c_str(), str.c_str());
|
|
|
}
|
|
|
if (num <= 0 && pconfig->num > 0)
|
|
|
{
|
|
|
pchannelLog->AddCheckstr(PrintLevel_3, 3, "result", "fail num = 0");
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 对距离有要求
|
|
|
if (pconfig->dis > 0)
|
|
|
{
|
|
|
pqxList->claDis();
|
|
|
}
|
|
|
|
|
|
if (pconfig->bok == 1 && num > 0)
|
|
|
{
|
|
|
// 只要有一个条件大于阈值参数，就NG;
|
|
|
std::string strresult = "param type=OK:";
|
|
|
bool bresult = true;
|
|
|
// 数量不满足要求。
|
|
|
if (num >= pconfig->num)
|
|
|
{
|
|
|
bresult = false;
|
|
|
strresult += "Num = false : " + std::to_string(num) + ">=" + std::to_string(pconfig->num) + ";";
|
|
|
int are = QX_ERROR_TYPE_NUM;
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
if (pqxList->qxList.at(i).nstatus == 1)
|
|
|
{
|
|
|
pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_NUM;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
strresult += "Num = true: " + std::to_string(num) + "<" + std::to_string(pconfig->num) + ";";
|
|
|
}
|
|
|
|
|
|
float fmaxLen = 0;
|
|
|
bool blenerror = false;
|
|
|
float allmindis = 99999999999;
|
|
|
bool bdiserror = false;
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
if (pqxList->qxList.at(i).nstatus == 1)
|
|
|
{
|
|
|
if (pqxList->qxList.at(i).length > fmaxLen)
|
|
|
{
|
|
|
fmaxLen = pqxList->qxList.at(i).length;
|
|
|
}
|
|
|
// 长度超过阈值
|
|
|
if (pqxList->qxList.at(i).length > pconfig->len)
|
|
|
{
|
|
|
blenerror = true;
|
|
|
pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_Len;
|
|
|
}
|
|
|
|
|
|
// 对距离有要求
|
|
|
if (pconfig->dis > 0)
|
|
|
{
|
|
|
if (pqxList->qxList.at(i).tem_dis_idx >= 0)
|
|
|
{
|
|
|
// 最小距离 大于 阈值
|
|
|
if (pqxList->qxList.at(i).tem_dis <= pconfig->dis)
|
|
|
{
|
|
|
bdiserror = true;
|
|
|
pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_DIS;
|
|
|
pqxList->qxList.at(i).fmindis = pqxList->qxList.at(i).tem_dis;
|
|
|
pqxList->qxList.at(i).nmindis_BlobIdx = pqxList->qxList.at(i).tem_dis_idx;
|
|
|
}
|
|
|
if (pqxList->qxList.at(i).tem_dis < allmindis)
|
|
|
{
|
|
|
allmindis = pqxList->qxList.at(i).tem_dis;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (blenerror)
|
|
|
{
|
|
|
bresult = false;
|
|
|
strresult += "Len = false : " + std::to_string(fmaxLen) + ">=" + std::to_string(pconfig->len) + ";";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
strresult += "Len = true: " + std::to_string(fmaxLen) + ">=" + std::to_string(pconfig->len) + ";";
|
|
|
}
|
|
|
if (bdiserror)
|
|
|
{
|
|
|
bresult = false;
|
|
|
strresult += "dis = false : " + std::to_string(allmindis) + ">=" + std::to_string(pconfig->dis) + ";";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
strresult += "dis = true: " + std::to_string(allmindis) + ">=" + std::to_string(pconfig->dis) + ";";
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
|
|
|
if (pqxList->qxList.at(i).nqx_type > QX_ERROR_TYPE_OK)
|
|
|
{
|
|
|
if (pqxList->qxList.at(i).result == 0)
|
|
|
{
|
|
|
pqxList->qxList.at(i).result = 1;
|
|
|
|
|
|
QX_RESULT tem;
|
|
|
tem.blobIdx = pqxList->qxList.at(i).blobIdx;
|
|
|
tem.qx_Num = num;
|
|
|
tem.mindis = pqxList->qxList.at(i).fmindis;
|
|
|
tem.flen = pqxList->qxList.at(i).length;
|
|
|
tem.error_Type = pqxList->qxList.at(i).nqx_type;
|
|
|
tem.camera_name = pqxList->qxList.at(i).camera_name;
|
|
|
tem.channel_name = pqxList->qxList.at(i).channel_name;
|
|
|
pchannelLog->AddCheckstr(PrintLevel_4, 3, "result = NG", "Add New qx,Blob idx %d type %d num %d dis %f len %f ", tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);
|
|
|
|
|
|
m_reultList.resultList.push_back(tem);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
|
|
|
std::string strresult = "param type=NG:";
|
|
|
bool bpass = true;
|
|
|
if (num >= pconfig->num)
|
|
|
{
|
|
|
strresult += "Num = true : " + std::to_string(num) + ">=" + std::to_string(pconfig->num) + ";";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bpass = false;
|
|
|
strresult += "Num = false: " + std::to_string(num) + "<" + std::to_string(pconfig->num) + ";";
|
|
|
}
|
|
|
if (fmaxarea >= pconfig->sum_area)
|
|
|
{
|
|
|
strresult += "maxarea = true : " + std::to_string(fmaxarea) + ">=" + std::to_string(pconfig->sum_area) + ";";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bpass = false;
|
|
|
strresult += "maxarea = false: " + std::to_string(fmaxarea) + "<" + std::to_string(pconfig->sum_area) + ";";
|
|
|
}
|
|
|
// 数量满足要求
|
|
|
if (bpass)
|
|
|
{
|
|
|
float allmindis = 99999999999;
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
// pchannelLog->AddCheckstr(PrintLevel_4, 3, "ddddddd", "%d %f %f %s ",
|
|
|
// i, pqxList->qxList.at(i).plocatin_mm.x, pqxList->qxList.at(i).plocatin_mm.y,
|
|
|
// pqxList->qxList.at(i).GetInfo().c_str());
|
|
|
|
|
|
// 面积 灰阶满足要求
|
|
|
if (pqxList->qxList.at(i).nstatus == 1)
|
|
|
{
|
|
|
|
|
|
int minidx = -1;
|
|
|
bool bdis = true;
|
|
|
double remindis = 0;
|
|
|
// 对距离有要求
|
|
|
if (pconfig->dis > 0)
|
|
|
{
|
|
|
// pchannelLog->AddCheckstr(PrintLevel_3, 3, "result", "%d %f",i,pqxList->qxList.at(i).tem_dis);
|
|
|
if (pqxList->qxList.at(i).tem_dis_idx >= 0)
|
|
|
{
|
|
|
|
|
|
// 最小距离 大于 阈值
|
|
|
if (pqxList->qxList.at(i).tem_dis > pconfig->dis)
|
|
|
{
|
|
|
bdis = false;
|
|
|
}
|
|
|
if (pqxList->qxList.at(i).tem_dis < allmindis)
|
|
|
{
|
|
|
allmindis = pqxList->qxList.at(i).tem_dis;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
remindis = pqxList->qxList.at(i).tem_dis;
|
|
|
}
|
|
|
|
|
|
// 距离满足要求
|
|
|
if (bdis && pqxList->qxList.at(i).result == 0)
|
|
|
{
|
|
|
pqxList->qxList.at(i).result = 1;
|
|
|
|
|
|
QX_RESULT tem;
|
|
|
tem.blobIdx = pqxList->qxList.at(i).blobIdx;
|
|
|
tem.qx_Num = num;
|
|
|
tem.mindis = remindis;
|
|
|
tem.camera_name = pqxList->qxList.at(i).camera_name;
|
|
|
tem.channel_name = pqxList->qxList.at(i).channel_name;
|
|
|
if (pconfig->num <= 0 && pconfig->dis <= 0)
|
|
|
{
|
|
|
tem.error_Type = QX_ERROR_TYPE_AREA;
|
|
|
}
|
|
|
else if (pconfig->dis <= 0)
|
|
|
{
|
|
|
tem.error_Type = QX_ERROR_TYPE_NUM;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
tem.error_Type = QX_ERROR_TYPE_DIS;
|
|
|
}
|
|
|
pchannelLog->AddCheckstr(PrintLevel_4, 3, "Add New QX",
|
|
|
"result = NG, Add New qx,Blob idx %d -> num %d >= %d is true; dis %f <= %f is true; max_area %f >= %f is true ",
|
|
|
tem.blobIdx, num, pconfig->num, remindis, pconfig->dis, fmaxarea, pconfig->sum_area);
|
|
|
|
|
|
m_reultList.resultList.push_back(tem);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (pconfig->dis > 0)
|
|
|
{
|
|
|
if (allmindis <= pconfig->dis)
|
|
|
{
|
|
|
strresult += "dis = true : " + std::to_string(allmindis) + "<=" + std::to_string(pconfig->dis) + ";";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bpass = false;
|
|
|
strresult += "dis = false : " + std::to_string(allmindis) + ">" + std::to_string(pconfig->dis) + ";";
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
strresult += "dis = true : dis param is 0";
|
|
|
}
|
|
|
}
|
|
|
if (!bpass)
|
|
|
{
|
|
|
pchannelLog->AddCheckstr(PrintLevel_2, 3, "result", "OK==>%s", strresult.c_str());
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pchannelLog->AddCheckstr(PrintLevel_2, 3, "result", "NG==>%s", strresult.c_str());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Analysis_QXtype(ALL_Qx_DataList *pALLTypeqxList, int qx_idx)
|
|
|
{
|
|
|
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "Num And Dis Judge", "pALLTypeqxList->channelqxList.size() %ld",
|
|
|
pALLTypeqxList->channelqxList.size());
|
|
|
for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
|
|
|
{
|
|
|
QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];
|
|
|
|
|
|
Analysis_Channel(pQXChannelList, qx_idx);
|
|
|
}
|
|
|
// AD 要进行额外的分析
|
|
|
if (qx_idx == QX_ANALYSIS_AD)
|
|
|
{
|
|
|
Analysis_AD(pALLTypeqxList, qx_idx);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Analysis_Channel(QX_channel_List *pChannelqxList, int qx_idx)
|
|
|
{
|
|
|
int param_num = 0;
|
|
|
int param_dis = 0;
|
|
|
|
|
|
ALL_QX_ParamList *pConfigList = &m_ConfigList[qx_idx];
|
|
|
// 用单面相机的参数去处理 所有相机的缺陷。
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "Num And Dis Judge", "pConfigList->configlsit.size() %ld",
|
|
|
pConfigList->configlsit.size());
|
|
|
for (int i = 0; i < (int)pConfigList->configlsit.size(); i++)
|
|
|
{
|
|
|
pChannelqxList->pChannelDetlog->AddCheckstr(PrintLevel_1, 3, "Num And Dis Judge", "QX %s channel %s param %d / %d Analysis start ",
|
|
|
QX_ANALYSIS_NAME_Names[qx_idx].c_str(), pChannelqxList->channel_name.c_str(), i, (int)pConfigList->configlsit.size());
|
|
|
Analysis_single_Config(&pConfigList->configlsit.at(i), pChannelqxList, qx_idx, pChannelqxList->pChannelDetlog);
|
|
|
}
|
|
|
if (pChannelqxList->pChannelDetlog2 && pChannelqxList->pChannelDetlog)
|
|
|
{
|
|
|
for (auto log : pChannelqxList->pChannelDetlog->logList)
|
|
|
{
|
|
|
pChannelqxList->pChannelDetlog2->logList.push_back(log);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Judge_OK_Config()
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Judge_NG_Config()
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int QX_Merge_Analysis::Analysis_AD(ALL_Qx_DataList *pALLTypeqxList, int qx_idx)
|
|
|
{
|
|
|
AD_list.clear();
|
|
|
if (!m_pbaseCheckFunction)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
Base_Function_AD_Check *pAd_checkParma = &m_pbaseCheckFunction->ad_check;
|
|
|
|
|
|
int product_AD_num = 0; // 整个产品的 暗点数目。
|
|
|
int check_s_Num = 0;
|
|
|
int s_param_value = -1;
|
|
|
int s_param_num = 0;
|
|
|
// 遍历每个通道，找到开启的 进行分析。
|
|
|
for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
|
|
|
{
|
|
|
QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];
|
|
|
|
|
|
if (!pAd_checkParma)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pAd_checkParma && !pAd_checkParma->bOpen)
|
|
|
{
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ",
|
|
|
"channel %s AD Check is close", pQXChannelList->channel_name.c_str());
|
|
|
continue;
|
|
|
}
|
|
|
bool bana_num = false;
|
|
|
bool bana_dis = false;
|
|
|
bool bana_S = false;
|
|
|
if (pAd_checkParma->analysis_num.bOpen)
|
|
|
{
|
|
|
bana_num = true;
|
|
|
}
|
|
|
if (pAd_checkParma->analysis_dis.bOpen)
|
|
|
{
|
|
|
bana_dis = true;
|
|
|
}
|
|
|
if (pAd_checkParma->analysis_s.bOpen)
|
|
|
{
|
|
|
bana_S = true;
|
|
|
}
|
|
|
{
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ", "NUM --> %s Param num check %d dis check %d S check %d",
|
|
|
pQXChannelList->channel_name.c_str(), bana_num, bana_dis, bana_S);
|
|
|
}
|
|
|
if (!bana_num && !bana_dis && !bana_S)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for (int j = 0; j < pQXChannelList->qxList.size(); j++)
|
|
|
{
|
|
|
if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_1s.area &&
|
|
|
pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_1s.len)
|
|
|
{
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
tem_AD_QX_Info tem_AD_qx; // 暗点信息
|
|
|
tem_AD_qx.channelidx = i;
|
|
|
tem_AD_qx.qxidx = j;
|
|
|
|
|
|
int s_det_value = 0;
|
|
|
// 当前通道 要参与s标准分析
|
|
|
if (pAd_checkParma->analysis_s.bOpen)
|
|
|
{
|
|
|
s_param_num = pAd_checkParma->analysis_s.Check_s_Num;
|
|
|
s_param_value = pAd_checkParma->analysis_s.Check_s_Value;
|
|
|
|
|
|
if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_3s.area &&
|
|
|
pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_3s.len)
|
|
|
{
|
|
|
s_det_value = 3;
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
|
|
|
"%d %s 3S: cur[A %0.2f L %0.2f] parm[A %0.2f L %0.2f]",
|
|
|
j, pQXChannelList->channel_name.c_str(),
|
|
|
pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
|
|
|
pAd_checkParma->S_standard_3s.area, pAd_checkParma->S_standard_3s.len);
|
|
|
}
|
|
|
else if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_2s.area &&
|
|
|
pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_2s.len)
|
|
|
{
|
|
|
s_det_value = 2;
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, " add AD ",
|
|
|
"%d %s 2S: cur[A %0.2f L %0.2f] parm[A %0.2f L %0.2f]",
|
|
|
j, pQXChannelList->channel_name.c_str(),
|
|
|
pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
|
|
|
pAd_checkParma->S_standard_2s.area, pAd_checkParma->S_standard_1s.len);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
|
|
|
"%d %s 1S: cur[A %0.2f L %0.2f] parm[A %0.2f L %0.2f]",
|
|
|
j, pQXChannelList->channel_name.c_str(),
|
|
|
pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
|
|
|
pAd_checkParma->S_standard_2s.area, pAd_checkParma->S_standard_1s.len);
|
|
|
s_det_value = 1;
|
|
|
}
|
|
|
if (s_det_value >= s_param_value)
|
|
|
{
|
|
|
check_s_Num++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cv::Rect roi = pQXChannelList->qxList[j].product_roi;
|
|
|
|
|
|
int list_idx = -1;
|
|
|
int channel_s = 0;
|
|
|
bool bnew_add = true;
|
|
|
for (int idx = 0; idx < AD_list.size(); idx++)
|
|
|
{
|
|
|
float fiou = CheckUtil::CalIoU(AD_list.at(idx).roi, roi);
|
|
|
if (fiou > 0.15)
|
|
|
{
|
|
|
list_idx = idx;
|
|
|
}
|
|
|
}
|
|
|
// 在list已存在。
|
|
|
if (list_idx >= 0)
|
|
|
{
|
|
|
AD_list.at(list_idx).num++;
|
|
|
AD_list.at(list_idx).numIdxList.push_back(tem_AD_qx);
|
|
|
|
|
|
channel_s = AD_list.at(list_idx).num;
|
|
|
if (s_det_value == 1)
|
|
|
{
|
|
|
AD_list.at(list_idx).num_1s++;
|
|
|
}
|
|
|
else if (s_det_value == 2)
|
|
|
{
|
|
|
AD_list.at(list_idx).num_2s++;
|
|
|
AD_list.at(list_idx).num_2sIdxList.push_back(tem_AD_qx);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
AD_list.at(list_idx).num_3s++;
|
|
|
AD_list.at(list_idx).num_3sIdxList.push_back(tem_AD_qx);
|
|
|
}
|
|
|
bnew_add = false;
|
|
|
}
|
|
|
else
|
|
|
{ // 在list不存在。
|
|
|
AD_Channel_Info_ tem;
|
|
|
tem.roi = roi;
|
|
|
tem.location_product_mm = pQXChannelList->qxList[j].pLocation_Product_mm;
|
|
|
tem.num = 1;
|
|
|
channel_s = 1;
|
|
|
tem.fdis = 99999999999;
|
|
|
|
|
|
tem.numIdxList.push_back(tem_AD_qx);
|
|
|
|
|
|
if (s_det_value == 1)
|
|
|
{
|
|
|
tem.num_1s++;
|
|
|
}
|
|
|
else if (s_det_value == 2)
|
|
|
{
|
|
|
tem.num_2s++;
|
|
|
tem.num_2sIdxList.push_back(tem_AD_qx);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
tem.num_3s++;
|
|
|
tem.num_3sIdxList.push_back(tem_AD_qx);
|
|
|
}
|
|
|
AD_list.push_back(tem);
|
|
|
// 如果要参与数量统计
|
|
|
if (bana_num)
|
|
|
{
|
|
|
product_AD_num++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "AD list size %ld; channel %s blob idx %d,new_add %d ,A %f len %f p %d %d",
|
|
|
AD_list.size(), pQXChannelList->channel_name.c_str(), j, bnew_add, pQXChannelList->qxList[j].area,
|
|
|
pQXChannelList->qxList[j].length, roi.x, roi.y);
|
|
|
|
|
|
pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ",
|
|
|
"%d %s AD list size %ld product_AD_num Num %d; cur channel num = %d;cur S = %ds; param :%ds num %d;->S check_s_Num = %d",
|
|
|
j, pQXChannelList->channel_name.c_str(), AD_list.size(),
|
|
|
product_AD_num, channel_s, s_det_value, s_param_value, s_param_num, check_s_Num);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
float min_dis = 9999999999;
|
|
|
// 求最小距离
|
|
|
if (true)
|
|
|
{
|
|
|
for (int ad_i = 0; ad_i < AD_list.size(); ad_i++)
|
|
|
{
|
|
|
for (int ad_j = 0; ad_j < AD_list.size(); ad_j++)
|
|
|
{
|
|
|
if (ad_i == ad_j)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
// double dis = DistanceBetweenRectCenters(AD_list.at(ad_i).roi, AD_list.at(ad_j).roi,
|
|
|
// 1,
|
|
|
// 1);
|
|
|
|
|
|
float dis = CheckUtil::calDis(AD_list.at(ad_i).location_product_mm, AD_list.at(ad_j).location_product_mm);
|
|
|
if (dis < AD_list.at(ad_i).fdis)
|
|
|
{
|
|
|
AD_list.at(ad_i).fdis = dis;
|
|
|
AD_list.at(ad_i).dist_idx = ad_j;
|
|
|
if (dis < min_dis)
|
|
|
{
|
|
|
min_dis = dis;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
int A_2S_num = 0;
|
|
|
int A_3S_num = 0;
|
|
|
// 统计 2s 总数
|
|
|
if (s_param_value > 0)
|
|
|
{
|
|
|
int channels = 0;
|
|
|
int oneimgs = check_s_Num;
|
|
|
|
|
|
for (int ad_i = 0; ad_i < AD_list.size(); ad_i++)
|
|
|
{
|
|
|
if (AD_list.at(ad_i).num > 1)
|
|
|
{
|
|
|
AD_list.at(ad_i).num_2s++;
|
|
|
for (int i = 0; i < AD_list.at(ad_i).numIdxList.size(); i++)
|
|
|
{
|
|
|
AD_list.at(ad_i).num_2sIdxList.push_back(AD_list.at(ad_i).numIdxList.at(i));
|
|
|
}
|
|
|
}
|
|
|
A_2S_num += AD_list.at(ad_i).num_2s;
|
|
|
A_3S_num += AD_list.at(ad_i).num_3s;
|
|
|
if(AD_list.at(ad_i).num_1s >= 3) A_3S_num++;
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "AD_list %d %s",
|
|
|
ad_i, AD_list.at(ad_i).GetInfo().c_str());
|
|
|
}
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "product_AD_num %d 2S_num = %d 3S_num s = %d min_dis %0.2f",
|
|
|
product_AD_num, A_2S_num, A_3S_num, min_dis);
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
|
|
|
{
|
|
|
QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];
|
|
|
|
|
|
if (!pAd_checkParma->bOpen)
|
|
|
{
|
|
|
|
|
|
continue;
|
|
|
}
|
|
|
bool bNG = false;
|
|
|
|
|
|
bool NG_num = false;
|
|
|
bool NG_3S = false;
|
|
|
bool NG_2S = false;
|
|
|
bool NG_dis = false;
|
|
|
|
|
|
if (pAd_checkParma->analysis_num.bOpen)
|
|
|
{
|
|
|
// 数量分析
|
|
|
if (product_AD_num >= pAd_checkParma->analysis_num.numT)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis --> %s result NG ,product_AD_num %d >= parm num %d",
|
|
|
pQXChannelList->channel_name.c_str(), product_AD_num, pAd_checkParma->analysis_num.numT);
|
|
|
bNG = true;
|
|
|
NG_num = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis--> %s result OK ,product_AD_num %d < parm num %d",
|
|
|
pQXChannelList->channel_name.c_str(), product_AD_num, pAd_checkParma->analysis_num.numT);
|
|
|
}
|
|
|
}
|
|
|
// 不NG
|
|
|
if (!bNG)
|
|
|
{
|
|
|
// 3S直接 NG
|
|
|
if (pAd_checkParma->analysis_s.NG_3s)
|
|
|
{
|
|
|
// 数量分析
|
|
|
if (A_3S_num >= 1)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s result NG 3S %d >= 1",
|
|
|
pQXChannelList->channel_name.c_str(), A_3S_num);
|
|
|
|
|
|
bNG = true;
|
|
|
NG_3S = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s result OK 3S %d < 1",
|
|
|
pQXChannelList->channel_name.c_str(), A_3S_num);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 不NG
|
|
|
if (!bNG)
|
|
|
{
|
|
|
// 距离判断
|
|
|
if (pAd_checkParma->analysis_dis.bOpen)
|
|
|
{
|
|
|
// 数量分析
|
|
|
if (min_dis <= pAd_checkParma->analysis_dis.disT)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis result NG ,min dis %f <= parm dis %f",
|
|
|
pQXChannelList->channel_name.c_str(), min_dis, pAd_checkParma->analysis_dis.disT);
|
|
|
|
|
|
bNG = true;
|
|
|
NG_2S = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis result OK ,min dis %f > parm dis %f",
|
|
|
pQXChannelList->channel_name.c_str(), min_dis, pAd_checkParma->analysis_dis.disT);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 不NG
|
|
|
if (!bNG)
|
|
|
{
|
|
|
// S标准判断
|
|
|
if (pAd_checkParma->analysis_s.bOpen)
|
|
|
{
|
|
|
// 数量分析
|
|
|
if (A_2S_num >= pAd_checkParma->analysis_s.Check_s_Num)
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s result NG , Check %ds Num %d >= parm S Num %d",
|
|
|
pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, A_2S_num, pAd_checkParma->analysis_s.Check_s_Num);
|
|
|
|
|
|
bNG = true;
|
|
|
NG_2S = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s result OK , Check %ds Num %d < parm S Num %d",
|
|
|
pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, A_2S_num, pAd_checkParma->analysis_s.Check_s_Num);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 已经NG
|
|
|
if (bNG)
|
|
|
{
|
|
|
|
|
|
QX_channel_List *pqxList = pQXChannelList;
|
|
|
for (int i = 0; i < (int)pqxList->qxList.size(); i++)
|
|
|
{
|
|
|
|
|
|
if (pqxList->qxList.at(i).result == 0)
|
|
|
{
|
|
|
pqxList->qxList.at(i).result = 1;
|
|
|
|
|
|
QX_RESULT tem;
|
|
|
tem.blobIdx = pqxList->qxList.at(i).blobIdx;
|
|
|
tem.mindis = pqxList->qxList.at(i).fmindis;
|
|
|
tem.flen = pqxList->qxList.at(i).length;
|
|
|
tem.error_Type = pqxList->qxList.at(i).nqx_type;
|
|
|
tem.camera_name = pqxList->qxList.at(i).camera_name;
|
|
|
tem.channel_name = pqxList->qxList.at(i).channel_name;
|
|
|
pqxList->pChannelDetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "Add New qx,Blob idx %d type %d num %d dis %f len %f ", tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);
|
|
|
m_pMergedetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "%s Add New qx,Blob idx %d type %d num %d dis %f len %f ",
|
|
|
tem.channel_name.c_str(), tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);
|
|
|
|
|
|
m_reultList.resultList.push_back(tem);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
ChannelCheckFunction *QX_Merge_Analysis::GetChannelFuntion(std::string strChannelName)
|
|
|
{
|
|
|
ChannelCheckFunction *p = NULL;
|
|
|
for (int i = 0; i < m_pChannelFuntion->channelFunctionArr.size(); i++)
|
|
|
{
|
|
|
if (CheckUtil::compareIgnoreCase(m_pChannelFuntion->channelFunctionArr[i].strChannelName, strChannelName))
|
|
|
{
|
|
|
p = &m_pChannelFuntion->channelFunctionArr[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return p;
|
|
|
}
|
|
|
double QX_Merge_Analysis::DistanceBetweenRectCenters(const cv::Rect &rect1, const cv::Rect &rect2, float fx, float fy)
|
|
|
{
|
|
|
// 计算矩形1的中心点
|
|
|
cv::Point center1(rect1.x + rect1.width / 2, rect1.y + rect1.height / 2);
|
|
|
|
|
|
// 计算矩形2的中心点
|
|
|
cv::Point center2(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
|
|
|
center1.x *= fx;
|
|
|
center1.y *= fy;
|
|
|
|
|
|
center2.x *= fx;
|
|
|
center2.y *= fy;
|
|
|
|
|
|
// 计算中心点之间的欧几里得距离
|
|
|
double distance = cv::norm(center1 - center2);
|
|
|
|
|
|
return distance;
|
|
|
} |
