You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
892 lines
21 KiB
892 lines
21 KiB
/*
|
|
* @Author: your name
|
|
* @Date: 2022-04-20 15:50:00
|
|
* @LastEditTime: 2025-09-24 11:03:35
|
|
* @LastEditors: xiewenji 527774126@qq.com
|
|
* @Description: 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
|
|
* @FilePath: /ZCXD_MonitorPlatform/src/CoreLogicModule/src/CamDeal.cpp
|
|
*/
|
|
#include "ALLImgCheckAnalysisy.hpp"
|
|
#include "CheckUtil.hpp"
|
|
#include "Define.h"
|
|
#include "AI_Factory.h"
|
|
#include <fstream>
|
|
|
|
std::vector<ReadFlawCode> m_FlawCodeList;
|
|
|
|
std::vector <std::string> QX_Result_Names =
|
|
{
|
|
"OK",
|
|
"AD_YX",
|
|
"X_Line",
|
|
"Y_Line",
|
|
"fangge",
|
|
"Rubbing_Mura",
|
|
"Broken_line",
|
|
"ZARA",
|
|
"MTX",
|
|
"POL_Cell",
|
|
"Bright_Point",
|
|
"Dark_Point",
|
|
"BLack_Point",
|
|
"White_Point",
|
|
"Scratch",
|
|
"Weak_Bright_Mura",
|
|
"No_Label",
|
|
"Bright_Mura_Exe",
|
|
"Sweak_Line_Dark",
|
|
"STEAM_POCKET",
|
|
"Dirty",
|
|
"other",
|
|
"Cell_W",
|
|
"Cell_B",
|
|
"LackPol"};
|
|
std::vector <std::string> QX_Result_Code =
|
|
{
|
|
"P1153",
|
|
"P6873",
|
|
"P3351",
|
|
"P3452",
|
|
"P3453",
|
|
"P1550",
|
|
"P3379",
|
|
"P1153",
|
|
"P1164",
|
|
"P1101",
|
|
"P1112",
|
|
"P1111",
|
|
"P1104",
|
|
"P1103",
|
|
"P1557",
|
|
"P1654",
|
|
"P2833",
|
|
"P1549",
|
|
"P1204",
|
|
"P2534",
|
|
"P2534",
|
|
"P1101",
|
|
"P1103",
|
|
"P1104",
|
|
"P8001",
|
|
};
|
|
|
|
|
|
int ReadFlawCodeConfig(std::string json_path)
|
|
{
|
|
m_FlawCodeList.erase(m_FlawCodeList.begin(), m_FlawCodeList.end());
|
|
std::string strPath = json_path;
|
|
printf("ReadFlawCodeConfig path %s\n", strPath.c_str());
|
|
Json::CharReaderBuilder builder;
|
|
builder["collectComments"] = true;
|
|
Json::Value root;
|
|
std::string err;
|
|
std::ifstream ifs(strPath);
|
|
if (!ifs.is_open())
|
|
{
|
|
printf("error:file is open\n");
|
|
return 0;
|
|
}
|
|
if (!Json::parseFromStream(builder, ifs, &root, &err))
|
|
{
|
|
printf("error:parseFromStream\n");
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 0; i < root.size(); i++)
|
|
{
|
|
// printf("Node idx %d /%d \n", i, root.size());
|
|
|
|
ReadFlawCode tem;
|
|
tem.flaw_name = root[i]["zh_name"].asString();
|
|
tem.flaw_code = root[i]["en_name"].asString();
|
|
string desc = root[i]["desc"].asString();
|
|
{
|
|
|
|
std::istringstream stream(desc);
|
|
std::string token;
|
|
|
|
// 使用 getline 按照分号分割
|
|
while (std::getline(stream, token, ';'))
|
|
{
|
|
tem.config_flaw_name.push_back(token);
|
|
}
|
|
}
|
|
m_FlawCodeList.push_back(tem);
|
|
}
|
|
for(int i = 0; i < m_FlawCodeList.size(); i++)
|
|
{
|
|
if(i >= QX_Result_Names.size()) {
|
|
QX_Result_Names.push_back(m_FlawCodeList.at(i).flaw_name);
|
|
QX_Result_Code.push_back(m_FlawCodeList.at(i).flaw_code);
|
|
}
|
|
else
|
|
{
|
|
QX_Result_Names.at(i) = m_FlawCodeList.at(i).flaw_name;
|
|
QX_Result_Code.at(i) = m_FlawCodeList.at(i).flaw_code;
|
|
}
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
double calculateDistanceBetweenRectCenters(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;
|
|
}
|
|
|
|
ALLImgCheckAnalysisy::ALLImgCheckAnalysisy()
|
|
{
|
|
m_strTest = "";
|
|
}
|
|
|
|
ALLImgCheckAnalysisy::~ALLImgCheckAnalysisy()
|
|
{
|
|
StopThread();
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::RunStart(void *pconfig1)
|
|
{
|
|
|
|
// 1、参数版本核对
|
|
int re = CheckConfigVersion(pconfig1);
|
|
if (re != 0)
|
|
{
|
|
printf("*************CheckConfigVersion error %d*************** \n", re);
|
|
m_nErrorCode = INIT_CameraCheck_Error;
|
|
return m_nErrorCode;
|
|
}
|
|
|
|
m_pParamName = ParmNameChange::getInstance();
|
|
m_pParamName->m_nWorkIdx = m_RunConfig.nWorkIdx;
|
|
// 2、初始化相机类
|
|
|
|
re = InitCameraCheckAnalysisy();
|
|
if (re != 0)
|
|
{
|
|
printf("*************InitCameraCheckAnalysisy error %d*************** \n", re);
|
|
m_nErrorCode = INIT_CameraCheck_Error;
|
|
return m_nErrorCode;
|
|
}
|
|
|
|
re = InitRun();
|
|
if (CHECK_OK != re)
|
|
{
|
|
m_nErrorCode = re;
|
|
return m_nErrorCode;
|
|
}
|
|
re = InitAIFactory();
|
|
if (CHECK_OK != re)
|
|
{
|
|
m_nErrorCode = re;
|
|
return m_nErrorCode;
|
|
}
|
|
m_nErrorCode = CHECK_OK;
|
|
printf(">>>> ALLImgCheckAnalysisy Start Succ \n");
|
|
|
|
m_nErrorCode = CHECK_OK;
|
|
m_bInitSucc = true;
|
|
return m_nErrorCode;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::SetDataRun_SharePtr(std::shared_ptr<shareImage> p)
|
|
{
|
|
|
|
int re = PushInImg_New(p);
|
|
if (re != 0)
|
|
{
|
|
printf("SetDataRun_SharePtr======================= re %d \n", re);
|
|
}
|
|
|
|
return re;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::GetCheckReuslt(std::shared_ptr<CheckResult> &pResult)
|
|
{
|
|
std::unique_lock<std::mutex> lk(mtx_CheckResult); // 使用 unique_lock
|
|
CheckResult_cond.wait(lk, [this]
|
|
{ return !m_CheckResultList.empty(); }); // 等待直到数据队列非空
|
|
pResult = m_CheckResultList.front(); // 从队列中取出数
|
|
m_CheckResultList.pop();
|
|
lk.unlock();
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::ReJson(std::shared_ptr<shareImage> p, std::shared_ptr<CheckResult> &pResult)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::CheckImg(std::shared_ptr<shareImage> p, std::shared_ptr<CheckResult> &pResult)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::GetStatus()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::UpdateConfig(void *pconfig, int nConfigType)
|
|
{
|
|
int re = 0;
|
|
RunInfoST *tempconfig;
|
|
switch (nConfigType)
|
|
{
|
|
case CHECK_CONFIG_Run:
|
|
tempconfig = (RunInfoST *)pconfig;
|
|
m_RunConfig.copy(*tempconfig);
|
|
break;
|
|
case CHECK_CONFIG_Module:
|
|
m_pConfigManager = (ConfigManagerBase *)pconfig;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::string ALLImgCheckAnalysisy::GetVersion()
|
|
{
|
|
return std::string("BOE_2.0.5");
|
|
}
|
|
|
|
std::string ALLImgCheckAnalysisy::GetErrorInfo()
|
|
{
|
|
std::string result = "";
|
|
|
|
return result;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::ErrorReturn(std::shared_ptr<shareImage> p)
|
|
{
|
|
|
|
std::shared_ptr<CheckResult> result = std::make_shared<CheckResult>();
|
|
result->in_shareImage = p;
|
|
result->checkStatus = 1;
|
|
result->nresult = -CHECK_ERROR_PushImg_ID_Error;
|
|
result->basicResult.img_id = p->img_id;
|
|
result->basicResult.imgtype = p->imgtype;
|
|
result->basicResult.imgstr = p->imgstr;
|
|
result->basicResult.strChannel = p->strChannel;
|
|
// printf("ErrorReturn==== %s %s\n", p->strImgProductID.c_str(), p->strChannel.c_str());
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_CheckResult);
|
|
m_CheckResultList.push(result);
|
|
}
|
|
CheckResult_cond.notify_all();
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::shared_ptr<Product> ALLImgCheckAnalysisy::GetProduct(std::string strProduct)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_ProductList);
|
|
for (int i = 0; i < m_ProductList.size(); i++)
|
|
{
|
|
// printf("ddd %s \n", m_ProductList.at(i)->productBaseResult->strproductName.c_str());
|
|
if (m_ProductList.at(i)->productBaseResult->strproductName == strProduct)
|
|
{
|
|
return m_ProductList.at(i);
|
|
}
|
|
}
|
|
|
|
return std::shared_ptr<Product>();
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::InitAIFactory()
|
|
{
|
|
std::shared_ptr<AIFactory> AI_Factory;
|
|
AI_Factory = AIFactory::GetInstance();
|
|
|
|
GPU_Config gpu;
|
|
int num = 0;
|
|
for (int i = 0; i < MAX_GPU_NUM; i++)
|
|
{
|
|
gpu.UseGPUList[i] = m_RunConfig.UseGPUList[i];
|
|
if (gpu.UseGPUList[i] >= 0)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
if (num == 0)
|
|
{
|
|
gpu.UseGPUList[0] = 0;
|
|
gpu.UseGPUList[1] = 1;
|
|
}
|
|
for (int i = 0; i < MAX_GPU_NUM; i++)
|
|
{
|
|
printf("=====InitAIFactory gpu %d %d \n", i, gpu.UseGPUList[i]);
|
|
}
|
|
|
|
AI_Factory->InitALLAIModle(gpu);
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::LoadRunConfig(void *p)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::LoadCheckConfig(void *p)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::InitRun()
|
|
{
|
|
int re;
|
|
re = StartThread();
|
|
if (CHECK_OK != re)
|
|
{
|
|
return re;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::StartCheck()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::SetIDLE()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::CheckConfigVersion(void *pconfig1)
|
|
{
|
|
int re = 0;
|
|
VERSION_INFO *pVersionconfig = (VERSION_INFO *)pconfig1;
|
|
if (pVersionconfig == NULL)
|
|
{
|
|
m_nErrorCode = CHECK_ERROR_VERSION; // 参数或接口版本问题
|
|
return m_nErrorCode;
|
|
}
|
|
|
|
int v1 = ALL_INTERFACE_VERSION;
|
|
int v2 = CONFIGBASE_VERSION;
|
|
int v3 = RESULT_VERSION;
|
|
printf("**************************** ALL_INTERFACE_VERSION so: %d in:%d CONFIGBASE_VERSION so:%d in:%d RESULT_VERSION so:%d in:%d\n",
|
|
v1, pVersionconfig->InterfaceVersion, v2, pVersionconfig->ConfigVersion, v3, pVersionconfig->ResultVersion);
|
|
// 版本控制
|
|
if (pVersionconfig->InterfaceVersion != ALL_INTERFACE_VERSION ||
|
|
pVersionconfig->ConfigVersion != CONFIGBASE_VERSION ||
|
|
pVersionconfig->ResultVersion != RESULT_VERSION)
|
|
{
|
|
m_nErrorCode = CHECK_ERROR_VERSION; // 参数或接口版本问题
|
|
return m_nErrorCode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::StartThread()
|
|
{
|
|
m_bExit = false;
|
|
|
|
{ // 开启检测线程
|
|
ptr_thread_Run = std::make_shared<std::thread>(std::bind(&ALLImgCheckAnalysisy::Run, this));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::StopThread()
|
|
{
|
|
m_bExit = true;
|
|
if (ptr_thread_Run != nullptr)
|
|
{
|
|
if (ptr_thread_Run->joinable())
|
|
{
|
|
ptr_thread_Run->join();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::ExitSystem()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::InitCameraCheckAnalysisy()
|
|
{
|
|
ReadFlawCodeConfig("/var/aidlux/efs/cell_aoi/model/defect_list.json");
|
|
m_pCameraCheckAnalysisyList.clear();
|
|
// m_pQX_Merge_Analysis->Clear();
|
|
for (const auto &config : m_pConfigManager->Config_instances_)
|
|
{
|
|
std::cout << "key: " << config.first << std::endl;
|
|
|
|
std::shared_ptr<CameraCheckAnalysisy> p = std::make_shared<CameraCheckAnalysisy>();
|
|
|
|
p->m_RunConfig.copy(m_RunConfig);
|
|
p->m_pConfig = config.second;
|
|
int re = p->Init(config.first);
|
|
if (re != 0)
|
|
{
|
|
std::cout << "Init CameraCheckAnalysisy " << config.first << " Failed" << std::endl;
|
|
return -1;
|
|
}
|
|
m_pCameraCheckAnalysisyList[config.first] = p;
|
|
// m_pQX_Merge_Analysis->AddCamer(config.first);
|
|
}
|
|
if (m_pCameraCheckAnalysisyList.size() < 0)
|
|
{
|
|
printf("ALLImgCheckAnalysisy::InitCameraCheckAnalysisy error camera config is null \n");
|
|
return 1;
|
|
/* code */
|
|
}
|
|
|
|
printf("ALLImgCheckAnalysisy::InitCameraCheckAnalysisy end \n");
|
|
// getchar();
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::InitData()
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::Det_Product(std::shared_ptr<Product> &product)
|
|
{
|
|
// m_pQX_Merge_Analysis->InitData();
|
|
// 处理每个相机
|
|
while (true)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
{
|
|
std::lock_guard<std::mutex> lock(product->mtx_CameraResultList); //
|
|
for (auto &ptr : product->m_pCameraResultList)
|
|
{
|
|
if (ptr->GetCheckStep() == Check_Step_NODet)
|
|
{
|
|
m_pCameraCheckAnalysisyList[ptr->cameraBaseResult->strCameraName]->StartCheck(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 判断每个相机是否都处理完了。
|
|
bool bdetComplete = product->bCheckCamplate();
|
|
// 处理完成，退出循环
|
|
if (bdetComplete)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 联合分析
|
|
// AnalysiyAll(0);
|
|
MergeShowImg(product);
|
|
SetProductResult(product);
|
|
printf(">>>>>>>>>>>>>>>Det_Product****************det End************\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::shared_ptr<Product> ALLImgCheckAnalysisy::GetProduct()
|
|
{
|
|
|
|
std::unique_lock<std::mutex> lk(mtx_ProductList); // 使用 unique_lock
|
|
ProductList_cond.wait(lk, [this]
|
|
{ return !m_ProductList.empty(); }); // 等待直到数据队列非空
|
|
std::shared_ptr<Product> tem = m_ProductList.at(0);
|
|
lk.unlock();
|
|
return tem;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::AnalysiyAll(int productIdx)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::SetProductResult(std::shared_ptr<Product> product)
|
|
{
|
|
|
|
int nDetCamNum = product->m_pCameraResultList.size();
|
|
// 相机2的起始位置
|
|
bool bNG = false;
|
|
for (int icam = 0; icam < nDetCamNum; icam++)
|
|
{
|
|
|
|
std::shared_ptr<CameraResult> pcam = product->m_pCameraResultList.at(icam);
|
|
for (int i = 0; i < pcam->ImageALLDetResultList.size(); i++)
|
|
{
|
|
|
|
std::shared_ptr<CheckResult> pCheckResult = pcam->ImageALLDetResultList.at(i)->result;
|
|
|
|
if (pCheckResult->qxImageResult.size() > 0)
|
|
{
|
|
bNG = true;
|
|
}
|
|
if (bNG)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (bNG)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (bNG)
|
|
{
|
|
for (int icam = 0; icam < nDetCamNum; icam++)
|
|
{
|
|
|
|
std::shared_ptr<CameraResult> pcam = product->m_pCameraResultList.at(icam);
|
|
for (int i = 0; i < pcam->ImageALLDetResultList.size(); i++)
|
|
{
|
|
|
|
std::shared_ptr<CheckResult> pCheckResult = pcam->ImageALLDetResultList.at(i)->result;
|
|
pCheckResult->nProductResult = 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::SetSetComplet_New(std::shared_ptr<Product> product, int nerror)
|
|
{
|
|
if (product)
|
|
{
|
|
|
|
int nDetCamNum = product->m_pCameraResultList.size();
|
|
for (int icam = 0; icam < nDetCamNum; icam++)
|
|
{
|
|
std::shared_ptr<CameraResult> pcam = product->m_pCameraResultList.at(icam);
|
|
for (int i = 0; i < pcam->ImageALLDetResultList.size(); i++)
|
|
{
|
|
std::shared_ptr<CheckResult> pCheckResult = pcam->ImageALLDetResultList.at(i)->result;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock123(mtx_CheckResult);
|
|
m_CheckResultList.push(pCheckResult);
|
|
}
|
|
CheckResult_cond.notify_all();
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ALLImgCheckAnalysisy::PushInImg_New(std::shared_ptr<shareImage> p)
|
|
{
|
|
|
|
if (!m_bInitSucc)
|
|
{
|
|
printf("Init fail exit \n");
|
|
return CHECK_ERROR_Config_Null;
|
|
}
|
|
|
|
p->strParm_WorkCamName = m_pParamName->GetWebConfigCamName_DetImgCamName(p->strCameraName);
|
|
|
|
std::string strlog = "";
|
|
m_strTest += " PushInImg->SN:";
|
|
m_strTest += p->strImgProductID;
|
|
m_strTest += " Channel:";
|
|
m_strTest += p->strChannel;
|
|
m_strTest += " CameraID:";
|
|
m_strTest += p->strCameraName;
|
|
m_strTest += " WorkCamName:";
|
|
m_strTest += p->strParm_WorkCamName;
|
|
std::string strBase = "";
|
|
strBase += " PushInImg->SN:";
|
|
strBase += p->strImgProductID;
|
|
strBase += " camera:";
|
|
strBase += p->strCameraName;
|
|
|
|
strBase += " WorkCamName:";
|
|
strBase += p->strParm_WorkCamName;
|
|
|
|
strBase += " Channel:";
|
|
strBase += p->strChannel;
|
|
printf("strBase %s p->Status %d\n", strBase.c_str(), p->Status);
|
|
std::shared_ptr<Product> product;
|
|
{
|
|
std::string strcameraName = p->strParm_WorkCamName;
|
|
|
|
// 判断 相机名称是否存在
|
|
if (!m_pCameraCheckAnalysisyList.count(strcameraName) && -1 != p->Status)
|
|
{
|
|
|
|
return CHECK_ERROR_Camear_ID_Error;
|
|
}
|
|
|
|
product = GetProduct(p->strImgProductID);
|
|
bool ProductID_Exist = false; // 是否存在当前产品ID
|
|
strlog += "productID ";
|
|
if (product)
|
|
{
|
|
strlog += "exist";
|
|
ProductID_Exist = true;
|
|
}
|
|
// 产品ID存在
|
|
if(ProductID_Exist)
|
|
{
|
|
// 模式为第一张图，返回异常
|
|
if(IN_IMG_Status_Start == p->Status)
|
|
{
|
|
cout << "---ProductID_Exist && IN_IMG_Status_Start == p->Status---" << endl;
|
|
return CHECK_ERROR_PRODUCT_ID_EXIST;
|
|
}
|
|
// 图片都已经完了的状态
|
|
if(product->bIsImgComplete)
|
|
{
|
|
cout << "---ProductID_Exist && product->bIsImgComplete is true---" << endl;
|
|
ErrorReturn(p);
|
|
return CHECK_ERROR_PRODUCT_ID_EXIST;
|
|
|
|
}
|
|
}
|
|
// 产品ID不存在
|
|
else
|
|
{
|
|
strlog += "isnot exist";
|
|
//设置其他m_ProductList送图状态设置为结束
|
|
cout << "-------set m_ProductList other product to end-------" << endl ;
|
|
std::lock_guard<std::mutex> lock(mtx_ProductList);
|
|
for(auto &tem:m_ProductList){
|
|
tem->bIsImgComplete = true;
|
|
}
|
|
if(-1 == p->Status)
|
|
{
|
|
return CHECK_ERROR_PushImg_ID_Error;
|
|
}
|
|
}
|
|
|
|
// 产品不存在 新建一个
|
|
if (!product)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_ProductList);
|
|
{
|
|
if (m_ProductList.size() > 50)
|
|
{
|
|
Clear_m_ProductList();
|
|
return CHECK_ERROR_PushImg_ListSize;
|
|
}
|
|
}
|
|
strlog += " | create new product";
|
|
product = std::make_shared<Product>();
|
|
product->productBaseResult->strproductName = p->strImgProductID;
|
|
if (m_CurProductIdx > 999999)
|
|
{
|
|
m_CurProductIdx = 0;
|
|
}
|
|
product->productUseCount = m_CurProductIdx;
|
|
m_CurProductIdx++;
|
|
m_ProductList.push_back(product);
|
|
std::string strTimg = CheckUtil::getCurTimeHMS();
|
|
product->productBaseResult->detlog->bPrintStr = true;
|
|
product->productBaseResult->detlog->AddCheckstr(PrintLevel_0, "PushInImg", "add new product %s %s ", p->strImgProductID.c_str(), strTimg.c_str());
|
|
}
|
|
else
|
|
{
|
|
strlog += " | product: ";
|
|
strlog += product->productBaseResult->strproductName;
|
|
// printf("Product Is %s \n", product->productBaseResult->strproductName.c_str());
|
|
}
|
|
|
|
// 送入图的状态 结束
|
|
if(-1 == p->Status)
|
|
{
|
|
strlog += " | p->Status == -1, set product complete";
|
|
product->bIsImgComplete = true;
|
|
}
|
|
// 送入图的状态 不是结束
|
|
else
|
|
{
|
|
strlog += " | create new camera result";
|
|
// 对应相机的 检测结果
|
|
std::shared_ptr<CameraResult> pCamera = product->GetCameraResult(strcameraName);
|
|
|
|
if (pCamera.get() == nullptr)
|
|
{
|
|
strlog += " | CHECK_ERROR_Camear_ID_Error";
|
|
product->productBaseResult->detlog->bPrintStr = true;
|
|
product->productBaseResult->detlog->AddCheckstr(PrintLevel_1, "PushInImg end", "%s", strlog.c_str());
|
|
ErrorReturn(p);
|
|
return CHECK_ERROR_Camear_ID_Error;
|
|
}
|
|
// 添加产品信息
|
|
pCamera->AddDetImage(p);
|
|
}
|
|
product->UpdatePushStatus(p->Status);
|
|
if (IN_IMG_Status_End == p->Status)
|
|
{
|
|
strlog += " | p->Status == IN_IMG_Status_End, set product complete";
|
|
product->bIsImgComplete = true;
|
|
m_strTest += "\n";
|
|
product->AddLog(m_strTest);
|
|
m_strTest = "";
|
|
}
|
|
product->productBaseResult->detlog->bPrintStr = true;
|
|
product->productBaseResult->detlog->AddCheckstr(PrintLevel_0, "PushInImg end", "%s", strlog.c_str());
|
|
ProductList_cond.notify_all();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
cv::Mat ALLImgCheckAnalysisy::hconcatWithFirstBase(const cv::Mat &img1, const cv::Mat &img2,
|
|
int interpolation = cv::INTER_LINEAR)
|
|
{
|
|
// 如果高度相同，直接拼接
|
|
if (img1.rows == img2.rows)
|
|
{
|
|
cv::Mat result;
|
|
cv::hconcat(img1, img2, result);
|
|
return result;
|
|
}
|
|
|
|
// 计算缩放比例
|
|
double scale = static_cast<double>(img1.rows) / img2.rows;
|
|
|
|
// 调整img2的高度
|
|
cv::Mat img2_resized;
|
|
cv::resize(img2, img2_resized, cv::Size(), scale, scale, interpolation);
|
|
|
|
// 拼接
|
|
cv::Mat result;
|
|
cv::hconcat(img1, img2_resized, result);
|
|
|
|
return result;
|
|
}
|
|
int ALLImgCheckAnalysisy::MergeShowImg(std::shared_ptr<Product> product)
|
|
{
|
|
int nDetCamNum = product->m_pCameraResultList.size();
|
|
// printf("MergeShowImg %s \n", product->productBaseResult->strproductName.c_str());
|
|
// 2个相机才操作
|
|
if (nDetCamNum == 2)
|
|
{
|
|
std::shared_ptr<CameraResult> pcam_0 = product->m_pCameraResultList.at(0);
|
|
std::shared_ptr<CameraResult> pcam_1 = product->m_pCameraResultList.at(1);
|
|
for (int i = 0; i < pcam_0->ImageALLDetResultList.size(); i++)
|
|
{
|
|
std::shared_ptr<CheckResult> pCheckResult_0 = pcam_0->ImageALLDetResultList.at(i)->result;
|
|
// printf("cam %s channel %s \n", pcam_0->cameraBaseResult->strCameraName.c_str(),
|
|
// pCheckResult_0->in_shareImage->strChannel.c_str());
|
|
for (int j = 0; j < pcam_1->ImageALLDetResultList.size(); j++)
|
|
{
|
|
std::shared_ptr<CheckResult> pCheckResult_1 = pcam_1->ImageALLDetResultList.at(j)->result;
|
|
|
|
if (pCheckResult_1->in_shareImage->strChannel == pCheckResult_0->in_shareImage->strChannel)
|
|
{
|
|
// printf("cam %s channel %s \n", pcam_1->cameraBaseResult->strCameraName.c_str(),
|
|
// pCheckResult_1->in_shareImage->strChannel.c_str());
|
|
|
|
if (!pCheckResult_0->resultimg.empty() && !pCheckResult_1->resultimg.empty())
|
|
{
|
|
cv::Mat meregeimg;
|
|
if (pCheckResult_0->in_shareImage->strCameraName == "left")
|
|
{
|
|
meregeimg = hconcatWithFirstBase(pCheckResult_0->resultimg, pCheckResult_1->resultimg);
|
|
}
|
|
else
|
|
{
|
|
meregeimg = hconcatWithFirstBase(pCheckResult_1->resultimg, pCheckResult_0->resultimg);
|
|
}
|
|
|
|
pCheckResult_0->resultimg = meregeimg;
|
|
pCheckResult_1->resultimg = meregeimg;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
void ALLImgCheckAnalysisy::Clear_m_ProductList(){
|
|
int num = m_ProductList.size();
|
|
string strlog = "";
|
|
printf("******************\n\n m_ProductImgDetResultList %ld \n", m_ProductList.size());
|
|
std::lock_guard<std::mutex> lock(mtx_ProductList);
|
|
int idx = -1;
|
|
for (int i = 0; i < m_ProductList.size(); i++)
|
|
{
|
|
int sub = std::abs(m_CurProductIdx - m_ProductList.at(i)->productUseCount);
|
|
if (sub > 50)
|
|
{
|
|
// 删除指定位置的元素
|
|
// m_ProductList.at(i)->productBaseResult->detlog->AddCheckstr(PrintLevel_0, "PushInImg", "%s Delete size > %d; m_CurProductIdx %d - nNotDetCount %d > 50",
|
|
// m_ProductList.at(i)->,
|
|
// m_ProductList.size(), m_CurProductIdx,
|
|
// m_ProductList.at(i)->productUseCount);
|
|
m_ProductList.erase(m_ProductList.begin() + i);
|
|
}
|
|
}
|
|
}
|
|
int ALLImgCheckAnalysisy::Run()
|
|
{
|
|
|
|
while (!m_bExit)
|
|
{
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
|
std::shared_ptr<Product> product = GetProduct();
|
|
|
|
int re = Det_Product(product);
|
|
// // 检测失败
|
|
// if (re != 0)
|
|
// {
|
|
// continue;
|
|
// }
|
|
SetSetComplet_New(product, re);
|
|
|
|
// 更新 产品队列
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_ProductList); //
|
|
if (!m_ProductList.empty())
|
|
{
|
|
m_ProductList.erase(m_ProductList.begin());
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
int ALLImgCheckAnalysisy::set_cpu_id(const std::vector<int> &cpu_set_vec)
|
|
{
|
|
// for cpu affinity
|
|
int nRet = 0;
|
|
#ifdef __linux
|
|
cpu_set_t _cur_cpu_set;
|
|
CPU_ZERO(&_cur_cpu_set);
|
|
for (auto _id : cpu_set_vec)
|
|
{
|
|
CPU_SET(_id, &_cur_cpu_set);
|
|
}
|
|
if (0 > pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &_cur_cpu_set))
|
|
{
|
|
perror("set cpu affinity failed: ");
|
|
printf("Warning: set cpu affinity failed ... ...\n");
|
|
nRet = -1;
|
|
}
|
|
#endif //__linux
|
|
return nRet;
|
|
}
|