Compare commits

...

17 Commits

@ -102,7 +102,7 @@ int main(int argc, char *argv[])
GPU_Config gpu;
gpu.gpu_0 = true;
gpu.gpu_1 = true;
gpu.gpu_1 = false;
AI_Factory->InitALLAIModle(gpu);
std::shared_ptr<AIModel_Base> BOE_Edge_Detect = AI_Factory->BOE_Edge_Detect;

@ -154,6 +154,7 @@ public:
private:
public:
std::shared_ptr<AIModel_Base> Defect;
std::shared_ptr<AIModel_Base> Defect_QueXi;
std::shared_ptr<AIModel_Base> Class;
std::shared_ptr<AIModel_Base> Pin_Loc;

@ -42,20 +42,31 @@ int AIFactory::InitALLAIModle(GPU_Config gupconfig)
Defect = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config edge_config;
edge_config.gpuconfig.copy(gupconfig);
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/Defect.engine";
edge_config.strName = "CA_Det";
edge_config.inputType = AIModel_Base::Input_HWC;
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/Defect.engine";
edge_config.strName = "Det";
edge_config.inputType = AIModel_Base::Input_CHW;
edge_config.Stream_num = 2;
Defect->Init(edge_config);
}
if (!Defect_QueXi)
{
Defect_QueXi = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config edge_config;
edge_config.gpuconfig.copy(gupconfig);
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/QueXi.engine";
edge_config.strName = "QueXi_Det";
edge_config.inputType = AIModel_Base::Input_CHW;
edge_config.Stream_num = 2;
Defect_QueXi->Init(edge_config);
}
if (!Class)
{
Class = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config jbl_config;
jbl_config.gpuconfig.copy(gupconfig);
jbl_config.strPath = "/home/aidlux/BOE/UseModel_ZB/Class_10.engine";
jbl_config.inputType = AIModel_Base::Input_HWC;
jbl_config.strName = "CA_Class";
jbl_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/Class.engine";
jbl_config.inputType = AIModel_Base::Input_CHW;
jbl_config.strName = "Class";
jbl_config.IsClass = true;
Class->Init(jbl_config);
}
@ -64,9 +75,9 @@ int AIFactory::InitALLAIModle(GPU_Config gupconfig)
Pin_Loc = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config edge_config;
edge_config.gpuconfig.copy(gupconfig);
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/PinLoc.engine";
edge_config.strName = "TA_Det";
edge_config.inputType = AIModel_Base::Input_HWC;
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/PinLoc.engine";
edge_config.strName = "Pin_Loc";
edge_config.inputType = AIModel_Base::Input_CHW;
edge_config.Stream_num = 2;
Pin_Loc->Init(edge_config);
}
@ -75,9 +86,9 @@ int AIFactory::InitALLAIModle(GPU_Config gupconfig)
Align_Outer = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config edge_config;
edge_config.gpuconfig.copy(gupconfig);
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/AlignOuter.engine";
edge_config.strName = "Align";
edge_config.inputType = AIModel_Base::Input_HWC;
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/AlignOuter.engine";
edge_config.strName = "Align_Outer";
edge_config.inputType = AIModel_Base::Input_CHW;
Align_Outer->Init(edge_config);
}
if (!Align_Inner)
@ -85,9 +96,9 @@ int AIFactory::InitALLAIModle(GPU_Config gupconfig)
Align_Inner = AIModel_Base::GetInstance();
AIModel_Base::AIModelRun_Config edge_config;
edge_config.gpuconfig.copy(gupconfig);
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/AlignInner.engine";
edge_config.strName = "Mark";
edge_config.inputType = AIModel_Base::Input_HWC;
edge_config.strPath = "/home/aidlux/BOE/UseModel_ZB/KK/AlignInner.engine";
edge_config.strName = "Align_Inner";
edge_config.inputType = AIModel_Base::Input_CHW;
Align_Inner->Init(edge_config);
}
m_bInitSucc = true;

@ -78,11 +78,14 @@ set(ModuleName "")
#
set(CMAKE_INSTALL_PREFIX /usr/local/zb_socket CACHE PATH "Install path prefix" FORCE)
set(HEADER_FILES include/ImgCheckBase.h include/ImgCheckConfig.h)
# _socket
set_target_properties(TY_Check PROPERTIES OUTPUT_NAME "TY_Check_socket")
#
install(TARGETS TY_Check
LIBRARY DESTINATION lib # CMAKE_INSTALL_PREFIX/lib
ARCHIVE DESTINATION lib/static
RUNTIME DESTINATION bin
PUBLIC_HEADER DESTINATION include) # CMAKE_INSTALL_PREFIX/include
#
install(FILES ${HEADER_FILES} DESTINATION include)
# _socket
install(FILES include/ImgCheckBase.h DESTINATION include RENAME ImgCheckBase_socket.h)
install(FILES include/ImgCheckConfig.h DESTINATION include RENAME ImgCheckConfig_socket.h)

@ -13,31 +13,27 @@
enum AI_CLass_QX_NAME_
{
AI_CLass_QX_NAME_aotudian, // 凹凸点
AI_CLass_QX_NAME_other, // 其他
AI_CLass_QX_NAME_line, // 线状
AI_CLass_QX_NAME_zangwu, // 脏污
AI_CLass_QX_NAME_dianzhuang, // 点状
AI_CLass_QX_NAME_posun, // 破损
AI_CLass_QX_NAME_xianwei, // 纤维
AI_CLass_QX_NAME_shuizi, // 水渍
AI_CLass_QX_NAME_danban, // 淡斑
AI_CLass_QX_NAME_fuchen, // 浮尘
AI_CLass_QX_NAME_PIN_PoSun, // PIN破损
AI_CLass_QX_NAME_PIN_QueShi, // PIN缺失
AI_CLass_QX_NAME_BTB_DuanLie, // BTB断裂
AI_CLass_QX_NAME_LianXi, // 连锡
AI_CLass_QX_NAME_QueXi, // 缺锡
AI_CLass_QX_NAME_YiWu, // 异物
AI_CLass_QX_NAME_C_BianXing, // C型卡口异常
AI_CLass_QX_NAME_other, // 其他
AI_CLass_QX_NAME_count,
};
// 缺陷项对应在参数中的名称
static const std::string AI_CLass_QX_NAME_Names[] =
{
"aotudian",
"qx",
"line",
"zangwu",
"dianzhuang",
"posun",
"xianwei",
"shuizi",
"danban",
"fuchen",
"PIN_PoSun",
"PIN_QueShi",
"BTB_DuanLie",
"LianXi",
"QueXi",
"YiWu",
"C_BianXing",
"other",
};
#endif

@ -65,6 +65,11 @@ public:
std::string GetErrorInfo();
// 获取模板外接矩形
const cv::RotatedRect &GetTplOuterRect() const { return m_tplOuterRect; }
// 获取模板 pin blob 轮廓点集
const std::vector<std::vector<cv::Point>> &GetTplPinContours() const { return m_tplPinContours; }
private:
// 加载运行参数
int LoadRunConfig(void *p);
@ -125,6 +130,9 @@ private:
int InitAIFactory();
// 初始化模板
int InitTemplateMask();
private:
// 图片处理线程
std::shared_ptr<std::thread> ptr_thread_Run;
@ -170,6 +178,9 @@ private:
std::string m_strTest;
// 模板信息
cv::RotatedRect m_tplOuterRect; // 模板外接矩形
std::vector<std::vector<cv::Point>> m_tplPinContours; // 模板 pin blob 轮廓点集
};

@ -133,6 +133,10 @@ public:
int Init(std::string strcameraName);
int StartCheck(std::shared_ptr<CameraResult> pCamera_Check_Result);
// 设置模板信息并转发给各个检测核心
void SetTplInfo(const cv::RotatedRect &outerRect,
const std::vector<std::vector<cv::Point>> &pinContours);
private:
// 开启线程
int StartThread();

@ -51,6 +51,9 @@ public:
static float Cal2PointAngle(cv::Point p_left, cv::Point p_right);
// 获取 RotatedRect 长轴的方向角(归一化到 [0, 180) 度)
static float getLongAxisAngle(const cv::RotatedRect rect);
// 排序RotatedRect的四个顶点
static std::vector<cv::Point2f> sort_vertices(cv::RotatedRect rrect);
// 找图片的最大外轮廓
static std::vector<cv::Point> getLargestContourROI(const cv::Mat &binaryImg, bool &found);
@ -59,6 +62,9 @@ public:
//创建目录
static int CreateDir(const std::string &dir);
// 异步存图
static int SaveImgAsync(const std::string &path, const cv::Mat &img);
// 点的距离是否过小
static bool bcalDis(cv::Point p1, cv::Point p2, int disT);
static double calDis(cv::Point p1, cv::Point p2);

@ -3,7 +3,7 @@
* @Date: 2025-09-11 15:32:52
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-14 17:41:14
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/include/ImageDetBase.h
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/include/ImageDetBase.h
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#ifndef ImageDetBase_H_

@ -80,6 +80,10 @@ public:
int creatsavedir();
// 设置模板信息(模板外接矩形 + 模板 pin blob 轮廓点集)
void SetTplInfo(const cv::RotatedRect &outerRect,
const std::vector<std::vector<cv::Point>> &pinContours);
private:
// 加载运行参数
int LoadRunConfig(void *p);
@ -195,7 +199,7 @@ private:
int BLobToDetResult();
//自适应参数区域更新
int Adapt_Config(Mat img, Rect roi, bool b_update);
int Adapt_Config(cv::RotatedRect tplOuterRect, cv::RotatedRect curOuterRect, cv::Mat& det_img);
std::shared_ptr<AIFactory> AI_Factory;
@ -287,6 +291,13 @@ private:
cv::Point m_old_cur_markLine_mark1;
cv::Point m_old_cur_markLine_mark2;
std::vector<RegionConfigST> m_old_cur_regionConfigArr;
// 模板信息
cv::RotatedRect m_tplOuterRect; // 模板外接矩形
cv::RotatedRect m_outer_rroi;
cv::RotatedRect m_inner_rroi;
std::vector<std::vector<cv::Point>> m_tplPinContours; // 模板 pin blob 轮廓点集
std::vector<std::vector<cv::Point>> m_curPinContours; // 当前 pin blob 轮廓点集
};
#endif

@ -47,19 +47,15 @@ struct VERSION_INFO
// 检测错误代码
enum ERROR_TYPE_
{
ERROR_TYPE_OK, // 1 疑是
ERROR_TYPE_aotudian, // 2 凹凸点
ERROR_TYPE_other, // 3 其他
ERROR_TYPE_line, // 4 线状
ERROR_TYPE_zangwu, // 5 脏污
ERROR_TYPE_edge, // 6 边缘
ERROR_TYPE_ymhs, // 7 研磨划伤
ERROR_TYPE_dianzhuang, // 8 点状
ERROR_TYPE_posun, // 9 破损
ERROR_TYPE_xianwei, // 10 纤维
ERROR_TYPE_shuizi, // 11 水渍
ERROR_TYPE_danban, // 12 淡斑
ERROR_TYPE_fuchen, // 13 浮尘
ERROR_TYPE_OK, // 0 正常/疑是
ERROR_TYPE_PIN_PoSun, // 1 PIN破损
ERROR_TYPE_PIN_QueShi, // 2 PIN缺失
ERROR_TYPE_BTB_DuanLie, // 3 BTB断裂
ERROR_TYPE_LianXi, // 4 连锡
ERROR_TYPE_QueXi, // 5 缺锡
ERROR_TYPE_YiWu, // 6 异物
ERROR_TYPE_C_BianXing, // 7 C型卡口异常
ERROR_TYPE_other, // 8 其他
ERROR_TYPE_COUNT,
};
extern std::vector<std::string> QX_Result_Names;

@ -3,7 +3,7 @@
* @Date: 2025-08-04 21:26:32
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-08-13 16:05:08
* @FilePath: /BOE_CELL_AOI/AlgorithmModule/include/Pin_QX_Det.h
* @FilePath: /BOE_ZB_SOCKET/AlgorithmModule/include/Pin_QX_Det.h
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
/*
@ -11,7 +11,7 @@
* @Date: 2025-08-04 21:26:32
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-08-04 21:29:05
* @FilePath: /BOE_CELL_AOI/AlgorithmModule/include/Pin_QX_Det.h
* @FilePath: /BOE_ZB_SOCKET/AlgorithmModule/include/Pin_QX_Det.h
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
/*
@ -59,10 +59,6 @@ public:
BaseCheckFunction *pBaseCheckFunction;
std::string strChannel;
std::vector<QX_Result> qx_result;
std::vector<Det_ROI_Config> pin_det_roi;
std::vector<cv::Point> Det_region;
bool bSaveResultImg;
DetConfigResult()
{
@ -72,106 +68,7 @@ public:
{
pBaseCheckFunction = NULL;
strChannel = "";
qx_result.clear();
pin_det_roi.clear();
Det_region.clear();
bSaveResultImg = false;
}
};
enum Det_ROI_Type
{
Det_ROI_Type_UP,
Det_ROI_Type_DOWN,
Det_ROI_Type_LEFT,
Det_ROI_Type_RIGHT,
};
// 边缘搜索定位结果
struct Pin_AI_Result
{
int nresult;
cv::RotatedRect bigroi;
cv::RotatedRect smallroi;
bool buseOfft;
int offt_x;
int offt_y;
cv::Mat H;
Pin_AI_Result()
{
Init();
}
void Init()
{
buseOfft = false;
nresult = 0;
offt_x = 0;
offt_y = 0;
bigroi = cv::RotatedRect(cv::Point2f(0, 0), cv::Size2f(0, 0), 0);
smallroi = cv::RotatedRect(cv::Point2f(0, 0), cv::Size2f(0, 0), 0);
if (!H.empty())
{
H.release();
/* code */
}
}
};
enum SaveProcessType
{
Save_Close, // 不保存
Save_Filter, // 过滤的
Save_ALL, // 全部
};
struct DetConfig
{
int ncamId; // 相机ID
BaseCheckFunction *pBaseCheckFunction;
std::string strChannel; // 通道
int nthresholdvalue; // 背景阈值
int nAIErodesize; // 边缘腐蚀强度
bool bSaveResultImg; // 保存结果图片
SaveProcessType saveProcessImg; // 保存过程图片
bool bUseDrawRoi_Check; // 是否用绘制的ROI进行校验
cv::Rect drawRoi; // 绘制的 ROi;
cv::Mat drawMask; // 绘制的maksk
DetConfig()
{
Init();
}
void Init()
{
pBaseCheckFunction = NULL;
ncamId = 0;
nthresholdvalue = 1;
nAIErodesize = 7;
bSaveResultImg = false;
saveProcessImg = Save_Close;
bUseDrawRoi_Check = false;
drawRoi = cv::Rect(0, 0, 0, 0);
if (!drawMask.empty())
{
drawMask.release();
/* code */
}
}
void Print()
{
printf("nthresholdvalue:%d;nAIErodesize %d;bSaveResultImg %s SaveProcessImg %d\n",
nthresholdvalue, nAIErodesize, BOOL_TO_STR(bSaveResultImg), saveProcessImg);
printf("bUseDrawRoi_Check %s roi %s \n",
BOOL_TO_STR(bUseDrawRoi_Check), CheckUtil::GetRectString(drawRoi).c_str());
}
bool IsSaveProcessImg()
{
if (saveProcessImg != Save_Close)
{
return true;
}
return false;
}
};
@ -179,30 +76,18 @@ public:
Pin_QX_Det(std::shared_ptr<DetLog>& log_ref);
~Pin_QX_Det();
int Detect(const cv::Mat &img, DetConfigResult *pDetConfig);
int GetPinMask(const cv::Mat &img, DetConfigResult *pDetConfig, Mat &mask);
private:
int InitModel_Pin();
int creatsavedir();
private:
bool m_bInitSucc; // 是否初始化成功
// 检测结果
std::shared_ptr<Pin_AI_Result> m_pCheckResult_Pin;
std::shared_ptr<DetLog>& m_pdetlog;
bool m_bInitialized;
bool m_bModelSucc;
bool m_bModel_Mark_Succ;
bool m_bshowimg;
cv::Mat showimg;
std::string m_strRootPath_Pin;
std::string m_strSavePath_Pin;
std::string m_strLastDate;
ImageStorage *m_pImageStorage;
std::shared_ptr<AIFactory> AI_Factory;

@ -3,7 +3,7 @@
* @Date: 2025-09-11 15:32:52
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-22 16:56:41
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/src/AI_Edge_Algin.cpp
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/src/AI_Edge_Algin.cpp
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/

@ -12,99 +12,6 @@
#include "AI_Factory.h"
#include <fstream>
std::vector<ReadFlawCode> m_FlawCodeList;
std::vector<std::string> QX_Result_Names =
{
"OK",
"aotudian",
"other",
"line",
"zangwu",
"edge",
"ymhs",
"dianzhuang",
"posun",
"xianwei",
"shuizi",
"danban",
"fuchen",
};
std::vector<std::string> QX_Result_Code =
{
"P0000",
"MA507",
"MA508",
"MA506",
"MA504",
"MA503",
"MA502",
"MA505",
"MA501",
"P0001",
"P0002",
"P0003",
"P0004",
};
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的中心点
@ -128,6 +35,9 @@ ALLImgCheckAnalysisy::ALLImgCheckAnalysisy()
{
m_strTest = "";
m_pdetlog = std::make_shared<DetLog>();
m_bInitSucc = false;
m_bExit = false;
}
ALLImgCheckAnalysisy::~ALLImgCheckAnalysisy()
@ -180,6 +90,20 @@ int ALLImgCheckAnalysisy::RunStart(void *pconfig1)
m_nErrorCode = re;
return m_nErrorCode;
}
re = InitTemplateMask();
if (CHECK_OK != re)
{
m_nErrorCode = re;
return m_nErrorCode;
}
// 把模板信息下发到各个相机检测实例
for (auto &item : m_pCameraCheckAnalysisyList)
{
if (item.second)
{
item.second->SetTplInfo(m_tplOuterRect, m_tplPinContours);
}
}
m_nErrorCode = CHECK_OK;
printf(">>>> ALLImgCheckAnalysisy Start Succ \n");
@ -238,6 +162,21 @@ int ALLImgCheckAnalysisy::UpdateConfig(void *pconfig, int nConfigType)
break;
case CHECK_CONFIG_Module:
m_pConfigManager = (ConfigManagerBase *)pconfig;
// 参数更新时,若系统已初始化,则重新计算模板并下发给各相机
if (m_bInitSucc)
{
re = InitTemplateMask();
if (re == 0)
{
for (auto &item : m_pCameraCheckAnalysisyList)
{
if (item.second)
{
item.second->SetTplInfo(m_tplOuterRect, m_tplPinContours);
}
}
}
}
break;
default:
break;
@ -301,12 +240,146 @@ int ALLImgCheckAnalysisy::InitAIFactory()
GPU_Config gpu;
gpu.gpu_0 = true;
gpu.gpu_1 = true;
gpu.gpu_1 = false;
AI_Factory->InitALLAIModle(gpu);
return 0;
}
int ALLImgCheckAnalysisy::InitTemplateMask()
{
std::shared_ptr<AIFactory> AI_Factory = AIFactory::GetInstance();
if (!AI_Factory || !AI_Factory->Align_Outer || !AI_Factory->Pin_Loc)
{
return -1;
}
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "---Init Tpl---" , "start");
// 模板图路径,暂时使用固定路径
string tplImgPath = "/home/aidlux/BOE/ZB_SOCKET/Tpl/tpl.bmp"; // 模板图片路径
Mat tplImg = imread(tplImgPath, IMREAD_UNCHANGED);
if (tplImg.empty())
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "", "Failed to load template image!");
return -2;
}
// 模板外接矩形,通过模型Align_Outer得到
RotatedRect tplOuterRect; // 模板外接矩形
std::shared_ptr<AIModel_Base> pSocket_Align;
pSocket_Align = AI_Factory->Align_Outer;
cv::Size sz;
sz.width = pSocket_Align->input_0.width;
sz.height = pSocket_Align->input_0.height;
cv::Mat detImg;
cout << "imgSize: " << tplImg.size() << ", " << "detImgSize: " << detImg.size() << ", " << "szSize: " << sz << endl;
cv::resize(tplImg, detImg, sz);
int re = 0;
cv::Mat mask;
if (detImg.channels() != 1)
{
cv::cvtColor(detImg, detImg, cv::COLOR_RGB2GRAY);
}
re = pSocket_Align->AIDet(detImg, mask);
if (re != 0)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "Init Tpl", "AICheck_Edge----error %d ", re);
int re123 = 100 + re;
return re123;
}
// 找到最大轮廓
bool found;
std::vector<cv::Point> boundingBox = CheckUtil::getLargestContourROI(mask, found);
if (!found)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "AI_Edge_Algin ", "No contours found!----error ");
return 4;
}
// 边缘轮廓点集还原为原图坐标并计算得到RotateROI
if (sz.width <= 0 || sz.height <= 0)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "AI_Edge_Algin ", "invalid model input size!----error ");
return 5;
}
// 检测小图 到 原图 的缩放比例
const float scale_x = static_cast<float>(tplImg.cols) / sz.width;
const float scale_y = static_cast<float>(tplImg.rows) / sz.height;
// 轮廓点还原到原图坐标系
std::vector<cv::Point2f> srcContour;
srcContour.reserve(boundingBox.size());
for (const auto &pt : boundingBox)
{
srcContour.emplace_back(pt.x * scale_x, pt.y * scale_y);
}
if (srcContour.size() < 3)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "AI_Edge_Algin ", "contour points too few!----error ");
return 6;
}
tplOuterRect = cv::minAreaRect(srcContour);
// 模板Pinmask通过模型Pin_Loc得到
Mat tplPinMask; // 模板mask
std::shared_ptr<AIModel_Base> pSocket_Pin;
pSocket_Pin = AI_Factory->Pin_Loc;
sz.width = pSocket_Pin->input_0.width;
sz.height = pSocket_Pin->input_0.height;
cv::Mat pinImg = tplImg(tplOuterRect.boundingRect()).clone(); // 裁剪模板图像为外接矩形区域
cout << "imgSize: " << tplImg.size() << ", " << "pinImgSize: " << pinImg.size() << ", " << "szSize: " << sz << endl;
cv::resize(pinImg, detImg, sz);
if (detImg.channels() != 1)
{
cv::cvtColor(detImg, detImg, cv::COLOR_RGB2GRAY);
}
re = pSocket_Pin->AIDet(detImg, tplPinMask);
if (re != 0)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "AI_Pin ", "AICheck_Pin----error %d ", re);
int re123 = 100 + re;
return re123;
}
// 统计tplPinMask的blob边缘点并绘制到tplImg上
vector<vector<Point>> pin_contours;
vector<Vec4i> hierarchy;
cv::findContours(tplPinMask, pin_contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
// mask 尺寸 -> 裁剪图(pinImg) 尺寸 的缩放比例
const float pin_scale_x = (tplPinMask.cols > 0) ? static_cast<float>(pinImg.cols) / tplPinMask.cols : 0.0f;
const float pin_scale_y = (tplPinMask.rows > 0) ? static_cast<float>(pinImg.rows) / tplPinMask.rows : 0.0f;
// 将轮廓点从 mask 坐标系 映射回 tplImg 坐标系
m_tplPinContours.clear();
m_tplPinContours.reserve(pin_contours.size());
for (size_t i = 0; i < pin_contours.size(); i++)
{
std::vector<cv::Point> mapped;
mapped.reserve(pin_contours[i].size());
for (const auto &pt : pin_contours[i])
{
mapped.emplace_back(cvRound(pt.x * pin_scale_x),
cvRound(pt.y * pin_scale_y));
}
m_tplPinContours.push_back(mapped);
}
// 保存模板外接矩形
m_tplOuterRect = tplOuterRect;
// 绘制到 tplImg 上
{
Mat showImg = pinImg.clone();
cv::drawContours(pinImg, m_tplPinContours, -1, Scalar(0, 255, 0), 2);
cv::imwrite("/home/aidlux/BOE/ZB_SOCKET/Tpl/tpl_pin_contours.png", pinImg);
}
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_1, "---Init Tpl---" , "end");
return 0;
}
int ALLImgCheckAnalysisy::LoadRunConfig(void *p)
{
return 0;
@ -370,14 +443,6 @@ int ALLImgCheckAnalysisy::ExitSystem()
int ALLImgCheckAnalysisy::InitCameraCheckAnalysisy()
{
string defect_list_file = m_pConfigManager->GetJsonPath();
if (defect_list_file == "") {
defect_list_file = "/var/aidlux/efs/model/defect_list.json";
}
else{
defect_list_file += "/defect_list.json";
}
ReadFlawCodeConfig(defect_list_file);
m_pCameraCheckAnalysisyList.clear();
for (const auto &config : m_pConfigManager->Config_instances_)
{
@ -418,7 +483,8 @@ int ALLImgCheckAnalysisy::InitData()
int ALLImgCheckAnalysisy::Det_Product(std::shared_ptr<Product> &product)
{
string cur_time_s = CheckUtil::getCurTimeHMS();
printf("[%s]>>>>>>>>>>>>>>>Det_Product****************det Start************\n", cur_time_s.c_str());
// 处理每个相机
while (true)
{
@ -447,8 +513,8 @@ int ALLImgCheckAnalysisy::Det_Product(std::shared_ptr<Product> &product)
// AnalysiyAll(0);
SetProductResult(product);
product->SetCheckEnd();
string cur_time = CheckUtil::getCurTimeHMS();
printf("[%s]>>>>>>>>>>>>>>>Det_Product****************det End************\n", cur_time.c_str());
string cur_time_e = CheckUtil::getCurTimeHMS();
printf("[%s]>>>>>>>>>>>>>>>Det_Product****************det End************\n", cur_time_e.c_str());
return 0;
}

@ -7,6 +7,7 @@
* @FilePath: /ZCXD_MonitorPlatform/src/CoreLogicModule/src/CamDeal.cpp
*/
#include "CameraCheckAnalysisy.hpp"
#include "ImgCheckAnalysisy.hpp"
#include "CheckUtil.hpp"
#include "Define.h"
@ -601,6 +602,19 @@ int CameraCheckAnalysisy::Init(std::string strcameraName)
return 0;
}
void CameraCheckAnalysisy::SetTplInfo(const cv::RotatedRect &outerRect,
const std::vector<std::vector<cv::Point>> &pinContours)
{
for (int i = 0; i < IMGCHECKANALYSISY_NUM; i++)
{
auto *p = static_cast<ImgCheckAnalysisy *>(m_pImgCheckAnalysisy[i]);
if (p)
{
p->SetTplInfo(outerRect, pinContours);
}
}
}
int CameraCheckAnalysisy::StartCheck(std::shared_ptr<CameraResult> pCamera_Check_Result)
{
if (m_bHaveImgeDet)

@ -3,7 +3,7 @@
* @Date: 2025-09-13 20:39:37
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-17 16:39:47
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/src/CameraResult.cpp
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/src/CameraResult.cpp
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#include "CameraResult.h"

@ -419,6 +419,26 @@ float CheckUtil::getLongAxisAngle(cv::RotatedRect rect) {
return long_axis_angle;
}
std::vector<cv::Point2f> CheckUtil::sort_vertices(cv::RotatedRect rrect) {
cv::Point2f pts[4];
rrect.points(pts);
std::vector<cv::Point2f> vertices(pts, pts + 4);
// 按 y 坐标升序排序
std::sort(vertices.begin(), vertices.end(),
[](const cv::Point2f& a, const cv::Point2f& b) {
return a.y < b.y;
});
if (vertices[0].x > vertices[1].x)
std::swap(vertices[0], vertices[1]);
if (vertices[2].x > vertices[3].x)
std::swap(vertices[2], vertices[3]);
return vertices;
}
std::vector<cv::Point> CheckUtil::getLargestContourROI(const cv::Mat &binaryImg, bool &found)
{
std::vector<std::vector<cv::Point>> contours;
@ -481,6 +501,32 @@ int CheckUtil::CreateDir(const std::string &dir)
return ret;
}
int CheckUtil::SaveImgAsync(const std::string &path, const cv::Mat &img)
{
if (path.empty() || img.empty())
{
return -1;
}
// 拷贝图像,避免异步线程执行时原图像被释放或修改
cv::Mat imgCopy = img.clone();
// 创建保存路径的父目录
std::string::size_type pos = path.find_last_of('/');
if (pos != std::string::npos)
{
std::string parentDir = path.substr(0, pos);
CheckUtil::CreateDir(parentDir);
}
// 启动后台线程异步存图
std::thread([path, imgCopy]() {
cv::imwrite(path, imgCopy);
}).detach();
return 0;
}
bool CheckUtil::bcalDis(cv::Point p1, cv::Point p2, int disT)
{
double dis = std::sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));

@ -3,7 +3,7 @@
* @Date: 2025-09-13 20:39:37
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-23 14:29:12
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/src/CameraResult.cpp
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/src/CameraResult.cpp
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#include "ImageAllResult.h"

@ -1044,41 +1044,29 @@ int ImageResultJudge::ConfigTypeToResultType(int nconfigType)
{
switch (nconfigType)
{
case CONFIG_QX_NAME_cell_aotudian:
resultError_type = ERROR_TYPE_aotudian;
case CONFIG_QX_NAME_PIN_PoSun:
resultError_type = ERROR_TYPE_PIN_PoSun;
break;
case CONFIG_QX_NAME_cell_other:
resultError_type = ERROR_TYPE_other;
break;
case CONFIG_QX_NAME_cell_line:
resultError_type = ERROR_TYPE_line;
break;
case CONFIG_QX_NAME_cell_zangwu:
resultError_type = ERROR_TYPE_zangwu;
case CONFIG_QX_NAME_PIN_QueShi:
resultError_type = ERROR_TYPE_PIN_QueShi;
break;
case CONFIG_QX_NAME_cell_edge:
resultError_type = ERROR_TYPE_edge;
case CONFIG_QX_NAME_BTB_DuanLie:
resultError_type = ERROR_TYPE_BTB_DuanLie;
break;
case CONFIG_QX_NAME_cell_ymhs:
resultError_type = ERROR_TYPE_ymhs;
case CONFIG_QX_NAME_LianXi:
resultError_type = ERROR_TYPE_LianXi;
break;
case CONFIG_QX_NAME_cell_dianzhuang:
resultError_type = ERROR_TYPE_dianzhuang;
case CONFIG_QX_NAME_QueXi:
resultError_type = ERROR_TYPE_QueXi;
break;
case CONFIG_QX_NAME_cell_posun:
resultError_type = ERROR_TYPE_posun;
case CONFIG_QX_NAME_YiWu:
resultError_type = ERROR_TYPE_YiWu;
break;
case CONFIG_QX_NAME_cell_xianwei:
resultError_type = ERROR_TYPE_xianwei;
case CONFIG_QX_NAME_C_BianXing:
resultError_type = ERROR_TYPE_C_BianXing;
break;
case CONFIG_QX_NAME_cell_shuizi:
resultError_type = ERROR_TYPE_shuizi;
break;
case CONFIG_QX_NAME_cell_danban:
resultError_type = ERROR_TYPE_danban;
break;
case CONFIG_QX_NAME_cell_fuchen:
resultError_type = ERROR_TYPE_fuchen;
case CONFIG_QX_NAME_other:
resultError_type = ERROR_TYPE_other;
break;
default:

@ -3,7 +3,7 @@
* @Date: 2025-09-11 15:32:52
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-16 09:40:36
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/src/ImageStorage.cpp
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/src/ImageStorage.cpp
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#include "ImageStorage.h"

File diff suppressed because it is too large Load Diff

@ -5,52 +5,18 @@
#include <random>
#include "CheckErrorCodeDefine.hpp"
int Pin_QX_Det::creatsavedir()
{
std::string curDate = CheckUtil::getCurrentDate();
if (curDate == m_strLastDate)
{
return 0;
}
m_strLastDate = curDate;
m_strSavePath_Pin = m_strRootPath_Pin + curDate + "/";
CheckUtil::CreateDir(m_strSavePath_Pin);
return 0;
return 0;
}
Pin_QX_Det::Pin_QX_Det(std::shared_ptr<DetLog> &log_ref)
: m_pdetlog(log_ref)
{
m_bInitialized = false;
m_bModelSucc = false;
m_bModel_Mark_Succ = false;
m_bshowimg = false;
m_strRootPath_Pin = "/home/aidlux/BOE/Pin/";
creatsavedir();
std::string m_strSavePath;
m_pImageStorage = ImageStorage::getInstance();
AI_Factory = AIFactory::GetInstance();
}
Pin_QX_Det::~Pin_QX_Det()
{
}
int Pin_QX_Det::Detect(const cv::Mat &img, DetConfigResult *pDetConfig)
{
// if (!pDetConfig->pBaseCheckFunction->edgeDet.bOpen)
// {
// return 0;
// }
m_bshowimg = false;
if (pDetConfig->bSaveResultImg)
{
m_bshowimg = true;
}
int Pin_QX_Det::GetPinMask(const cv::Mat &img, DetConfigResult *pDetConfig, Mat &mask)
{
std::shared_ptr<AIModel_Base> pSocket_Pin;
pSocket_Pin = AI_Factory->Pin_Loc;
cv::Size sz;
@ -62,7 +28,6 @@ int Pin_QX_Det::Detect(const cv::Mat &img, DetConfigResult *pDetConfig)
cv::resize(img, detImg, sz);
int re = 0;
cv::Mat mask;
if (detImg.channels() != 1)
{
cv::cvtColor(detImg, detImg, cv::COLOR_RGB2GRAY);
@ -71,27 +36,16 @@ int Pin_QX_Det::Detect(const cv::Mat &img, DetConfigResult *pDetConfig)
re = pSocket_Pin->AIDet(detImg, mask);
if (re != 0)
{
m_pdetlog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "AI_Edge_Algin ", "AICheck_Edge----error %d ", re);
m_pdetlog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "AI_Pin ", "AICheck_Pin----error %d ", re);
int re123 = 100 + re;
return re123;
}
if (pDetConfig->pBaseCheckFunction->saveImg.bSaveAlginImg)
{
}
if (pDetConfig->bSaveResultImg)
{
cv::imwrite(pDetConfig->strChannel +"_pin_" +"in.png", detImg);
cv::imwrite(pDetConfig->strChannel +"_pin_" +"out_mask.png", mask);
}
if (m_bshowimg)
{
cv::cvtColor(img, showimg, cv::COLOR_GRAY2BGR);
}
return 0;
}
}

@ -3,7 +3,7 @@
* @Date: 2025-09-13 19:26:19
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-17 18:10:38
* @FilePath: /BOE_CELL_AOI_Detect/AlgorithmModule/src/Product.cpp
* @FilePath: /BOE_ZB_SOCKET_Detect/AlgorithmModule/src/Product.cpp
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*
*/

@ -32,11 +32,13 @@ set(ModuleName "")
#
set(CMAKE_INSTALL_PREFIX /usr/local/polet CACHE PATH "Install path prefix" FORCE)
set(HEADER_FILES include/ConfigBase.h)
# _socket
set_target_properties(Config PROPERTIES OUTPUT_NAME "Config_socket")
#
install(TARGETS Config
LIBRARY DESTINATION lib # CMAKE_INSTALL_PREFIX/lib
ARCHIVE DESTINATION lib/static
RUNTIME DESTINATION bin
PUBLIC_HEADER DESTINATION include) # CMAKE_INSTALL_PREFIX/include
#
install(FILES ${HEADER_FILES} DESTINATION include)
# _socket
install(FILES include/ConfigBase.h DESTINATION include RENAME ConfigBase_socket.h)

@ -39,35 +39,29 @@ static const std::string WHITE_BLCAK_Names[] =
// 检测缺陷的种类
enum CONFIG_QX_NAME_
{
CONFIG_QX_NAME_cell_aotudian, // 分类 凹凸点
CONFIG_QX_NAME_cell_other, // 分类 其他
CONFIG_QX_NAME_cell_line, // 分类 线状
CONFIG_QX_NAME_cell_zangwu, // 分类 脏污
CONFIG_QX_NAME_cell_edge, // 分类 边缘
CONFIG_QX_NAME_cell_ymhs, // 分类 异物
CONFIG_QX_NAME_cell_dianzhuang, // 分类 点状
CONFIG_QX_NAME_cell_posun, // 分类 破损
CONFIG_QX_NAME_cell_xianwei, // 分类 纤维
CONFIG_QX_NAME_cell_shuizi, // 分类 水渍
CONFIG_QX_NAME_cell_danban, // 分类 淡斑
CONFIG_QX_NAME_cell_fuchen, // 分类 浮尘
CONFIG_QX_NAME_PIN_PoSun, // 分类 PIN破损
CONFIG_QX_NAME_PIN_QueShi, // 分类 PIN缺失
CONFIG_QX_NAME_BTB_DuanLie, // 分类 BTB断裂
CONFIG_QX_NAME_LianXi, // 分类 连锡
CONFIG_QX_NAME_QueXi, // 分类 缺锡
CONFIG_QX_NAME_YiWu, // 分类 异物
CONFIG_QX_NAME_C_BianXing, // 分类 C型卡口异常
CONFIG_QX_NAME_other, // 分类 其他
CONFIG_QX_NAME_PIN_PianYi, // 分类 PIN偏移
CONFIG_QX_NAME_count,
};
// 缺陷项对应在参数中的名称
static std::vector<std::string> CONFIG_QX_NAME_Names =
{
"aotudian",
"PIN_PoSun",
"PIN_QueShi",
"BTB_DuanLie",
"LianXi",
"QueXi",
"YiWu",
"C_BianXing",
"other",
"line",
"zangwu",
"edge",
"ymhs",
"dianzhuang",
"posun",
"xianwei",
"shuizi",
"danban",
"fuchen",
"PIN_PianYi",
};
// 分析类型
@ -1018,52 +1012,44 @@ struct ChannelCheckFunction
};
// 基础检测功能 mark
struct Base_Function_MarkLine
struct Base_Function_ALign
{
bool bOpen; // 是否开启
bool bDraw; // 是否绘制
bool badapt_region; // 是否自适应区域
cv::Rect productROI;
std::vector<cv::Point> region;
cv::Point mark_local_1;
cv::Point mark_local_2;
float angle_diff;
float x_offset;
float y_offset;
Base_Function_MarkLine()
Base_Function_ALign()
{
Init();
}
void Init()
{
bOpen = false;
bDraw = false;
badapt_region = false;
mark_local_1 = cv::Point(0, 0);
mark_local_2 = cv::Point(0, 0);
productROI = cv::Rect(0, 0, 0, 0);
region.clear();
angle_diff = 0.0;
x_offset = 0.0;
y_offset = 0.0;
}
void copy(Base_Function_MarkLine tem)
void copy(Base_Function_ALign tem)
{
this->bOpen = tem.bOpen;
this->region.assign(tem.region.begin(), tem.region.end());
this->productROI = tem.productROI;
this->bDraw = tem.bDraw;
this->badapt_region = tem.badapt_region;
this->mark_local_1 = tem.mark_local_1;
this->mark_local_2 = tem.mark_local_2;
this->angle_diff = tem.angle_diff;
this->x_offset = tem.x_offset;
this->y_offset = tem.y_offset;
}
void print(std::string str)
{
printf("%s>>bOpen %d bDraw %d badapt_region %d mark1 [%d %d] mark2 [%d %d] \n", str.c_str(),
bOpen, bDraw, badapt_region,mark_local_1.x, mark_local_1.y, mark_local_2.x, mark_local_2.y);
printf("%s>>bOpen %d angle_diff %f x_offset %f y_offset %f \n", str.c_str(),
bOpen, angle_diff, x_offset, y_offset);
}
std::string GetInfo(std::string str)
{
char buffer[256];
sprintf(buffer, "%s>>bOpen %d bDraw %d badapt_region %d mark1 [%d %d] mark2 [%d %d] \n", str.c_str(),
bOpen, bDraw, badapt_region,mark_local_1.x, mark_local_1.y, mark_local_2.x, mark_local_2.y);
sprintf(buffer, "%s>>bOpen %d angle_diff %f x_offset %f y_offset %f \n", str.c_str(),
bOpen, angle_diff, x_offset, y_offset);
std::string str123 = buffer;
return str123;
}
@ -1206,91 +1192,43 @@ struct Base_Function_BigNG
}
};
// 基础检测功能 CELL AOI 边缘缺陷检测
struct Base_Function_Edge_Det
struct Base_Function_Pin_Det
{
bool bOpen; // 是否开启
int Search_threshold; // 搜索边缘阈值
int Det_threshold; // 缺陷检测阈值
int Det_Range; // 检测范围
int QX_Widht_min; // 缺陷宽度-最小
int QX_Widht_max;
int QX_Height_min;
int QX_Height_max;
bool queJiao_LU_Open;
bool queJiao_RU_Open;
bool queJiao_LD_Open;
bool queJiao_RD_Open;
int queJiao_width;
int queJiao_height;
bool bDrawRoi;
cv::Rect draw_ROI;
std::vector<cv::Point> region;
bool bDrawResult; // 是否绘制结果
Base_Function_Edge_Det()
float pin_x_offset; // pin x 偏移
float pin_y_offset; // pin y 偏移
bool bDrawResult; // 是否绘制结果
Base_Function_Pin_Det()
{
Init();
}
void Init()
{
bOpen = false;
Search_threshold = 30;
Det_threshold = 30;
Det_Range = 100;
QX_Widht_min = 10;
QX_Widht_max = 100;
QX_Height_min = 10;
QX_Height_max = 100;
queJiao_LU_Open = false;
queJiao_RU_Open = false;
queJiao_LD_Open = false;
queJiao_RD_Open = false;
queJiao_width = 50;
queJiao_height = 50;
bDrawRoi = false;
draw_ROI = cv::Rect(0, 0, 0, 0);
region.clear();
region.erase(region.begin(), region.end());
pin_x_offset = 0;
pin_y_offset = 0;
bDrawResult = false;
}
void copy(Base_Function_Edge_Det tem)
void copy(Base_Function_Pin_Det tem)
{
this->bOpen = tem.bOpen;
this->Search_threshold = tem.Search_threshold;
this->Det_threshold = tem.Det_threshold;
this->Det_Range = tem.Det_Range;
this->QX_Widht_min = tem.QX_Widht_min;
this->QX_Widht_max = tem.QX_Widht_max;
this->QX_Height_min = tem.QX_Height_min;
this->QX_Height_max = tem.QX_Height_max;
this->queJiao_LU_Open = tem.queJiao_LU_Open;
this->queJiao_RU_Open = tem.queJiao_RU_Open;
this->queJiao_LD_Open = tem.queJiao_LD_Open;
this->queJiao_RD_Open = tem.queJiao_RD_Open;
this->queJiao_width = tem.queJiao_width;
this->queJiao_height = tem.queJiao_height;
this->region.assign(tem.region.begin(), tem.region.end());
this->draw_ROI = tem.draw_ROI;
this->bDrawRoi = tem.bDrawRoi;
this->pin_x_offset = tem.pin_x_offset;
this->pin_y_offset = tem.pin_y_offset;
this->bDrawResult = tem.bDrawResult;
}
void print(std::string str)
{
printf("%s>>bOpen %d Search_threshold %d Det_threshold %d Det_Range %d QX_Widht [%d %d] QX_Height [%d %d]\n", str.c_str(),
bOpen, Search_threshold, Det_threshold, Det_Range, QX_Widht_min, QX_Widht_max, QX_Height_min, QX_Height_max);
printf("%s>>bOpen %d pin_x_offset %f pin_y_offset %f bDrawResult %d\n", str.c_str(),
bOpen, pin_x_offset, pin_y_offset, bDrawResult);
}
std::string GetInfo(std::string str)
{
char buffer[256];
sprintf(buffer, "%s>>bOpen %d Search_threshold %d Det_threshold %d Det_Range %d QX_Widht [%d %d] QX_Height [%d %d]\n", str.c_str(),
bOpen, Search_threshold, Det_threshold, Det_Range, QX_Widht_min, QX_Widht_max, QX_Height_min, QX_Height_max);
sprintf(buffer, "%s>>bOpen %d pin_x_offset %f pin_y_offset %f bDrawResult %d\n", str.c_str(),
bOpen, pin_x_offset, pin_y_offset, bDrawResult);
std::string str123 = buffer;
return str123;
}
@ -1298,8 +1236,8 @@ struct Base_Function_Edge_Det
// 基础检测功能
struct BaseCheckFunction
{
Base_Function_MarkLine markLine;
Base_Function_Edge_Det edgeDet;
Base_Function_ALign ALign_Config;
Base_Function_Pin_Det pinDet;
Base_Function_SaveImg saveImg;
Base_Function_BigNG bigNG;
BaseCheckFunction()
@ -1308,31 +1246,31 @@ struct BaseCheckFunction
}
void Init()
{
markLine.Init();
edgeDet.Init();
ALign_Config.Init();
pinDet.Init();
saveImg.Init();
bigNG.Init();
}
void copy(BaseCheckFunction tem)
{
this->markLine.copy(tem.markLine);
this->edgeDet.copy(tem.edgeDet);
this->ALign_Config.copy(tem.ALign_Config);
this->pinDet.copy(tem.pinDet);
this->saveImg.copy(tem.saveImg);
this->bigNG.copy(tem.bigNG);
}
void print(std::string str)
{
printf("******* %s *********\n", str.c_str());
markLine.print("markLine");
edgeDet.print("edgeDet");
ALign_Config.print("ALign_Config");
pinDet.print("pinDet");
saveImg.print("saveImg");
bigNG.print("bigNG");
}
std::string GetInfo(std::string str)
{
std::string str123 = "";
str123 += markLine.GetInfo("markLine");
str123 += edgeDet.GetInfo("edgeDet");
str123 += ALign_Config.GetInfo("ALign_Config");
str123 += pinDet.GetInfo("pinDet");
str123 += saveImg.GetInfo("saveImg");
str123 += bigNG.GetInfo("bigNG");
// str123 += "\n";

@ -3,7 +3,7 @@
* @Date: 2025-09-11 15:32:54
* @LastEditors: xiewenji 527774126@qq.com
* @LastEditTime: 2025-09-13 18:49:40
* @FilePath: /BOE_CELL_AOI_Detect/ConfigModule/include/ConfigBase.h
* @FilePath: /BOE_ZB_SOCKET_Detect/ConfigModule/include/ConfigBase.h
* @Description: ,`customMade`, koroFileHeader : https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#ifndef ConfigBase_H_

@ -20,21 +20,19 @@ ConfigManager::~ConfigManager()
{
}
std::vector<ReadFlawCode> m_FlawCodeList;
std::vector<std::string> QX_Result_Names =
{
"OK",
"aotudian",
"PIN_PoSun",
"PIN_QueShi",
"BTB_DuanLie",
"LianXi",
"QueXi",
"YiWu",
"C_BianXing",
"other",
"line",
"zangwu",
"edge",
"ymhs",
"dianzhuang",
"posun",
"xianwei",
"shuizi",
"danban",
"fuchen",
};
std::vector<std::string> QX_Result_Code =
{
@ -42,15 +40,11 @@ std::vector<std::string> QX_Result_Code =
"MA507",
"MA508",
"MA506",
"MA504",
"MA504",
"MA503",
"MA502",
"MA505",
"MA501",
"P0001",
"P0002",
"P0003",
"P0004",
};
int ReadFlawCodeConfig(std::string json_path)

@ -775,78 +775,25 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
auto value_f = value;
// std::cout << value_f << std::endl;
// getchar();
_config.markLine.bOpen = value_f["isOpen"].asBool();
if (_config.markLine.bOpen)
_config.ALign_Config.bOpen = value_f["isOpen"].asBool();
if (_config.ALign_Config.bOpen)
{
{
auto crop_roi = value_f["form"]["ALign_Config"]["Product_ROI"];
// 2、读取区域点
{
auto value_region = value_f["form"]["ALign_Config"]["Product_ROI"];
if (value_region.isArray())
{
for (int idx = 0; idx < value_region.size(); idx++)
{
cv::Point p;
p.x = value_region[idx][0].asInt();
p.y = value_region[idx][1].asInt();
_config.markLine.region.emplace_back(p);
}
if (_config.markLine.region.size() > 0)
{
_config.markLine.productROI = boundingRect(_config.markLine.region);
}
}
}
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
}
if (value_f["form"]["ALign_Config"]["bDraw"])
if (value_f["form"]["ALign_Config"]["angle_diff"])
{
_config.markLine.bDraw = value_f["form"]["ALign_Config"]["bDraw"].asBool();
_config.ALign_Config.angle_diff = value_f["form"]["ALign_Config"]["angle_diff"].asFloat();
}
if (value_f["form"]["ALign_Config"]["badapt_region"])
if (value_f["form"]["ALign_Config"]["x_offset"])
{
_config.markLine.badapt_region = value_f["form"]["ALign_Config"]["badapt_region"].asBool();
_config.ALign_Config.x_offset = value_f["form"]["ALign_Config"]["x_offset"].asFloat();
}
if (value_f["form"]["ALign_Config"]["y_offset"])
{
auto value_circl = value_f["form"]["ALign_Config"]["mark_1_Local"]["path"];
if (value_circl.isArray())
{
if (value_circl[0][0])
{
_config.markLine.mark_local_1.x = value_circl[0][0].asInt();
}
if (value_circl[0][1])
{
_config.markLine.mark_local_1.y = value_circl[0][1].asInt();
}
}
}
{
auto value_circl = value_f["form"]["ALign_Config"]["mark_2_Local"]["path"];
if (value_circl.isArray())
{
if (value_circl[0][0])
{
_config.markLine.mark_local_2.x = value_circl[0][0].asInt();
}
if (value_circl[0][1])
{
_config.markLine.mark_local_2.y = value_circl[0][1].asInt();
}
}
_config.ALign_Config.y_offset = value_f["form"]["ALign_Config"]["y_offset"].asFloat();
}
// _config.markLine.print("dfe");
// getchar();
}
else
{
_config.markLine.Init();
_config.ALign_Config.Init();
}
}
if ("Pin_QX_Detect" == strCode)
@ -854,108 +801,28 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
auto value_f = value;
// std::cout << value_f << std::endl;
// getchar();
_config.edgeDet.bOpen = value_f["isOpen"].asBool();
if (_config.edgeDet.bOpen)
_config.pinDet.bOpen = value_f["isOpen"].asBool();
if (_config.pinDet.bOpen)
{
if (value_f["form"]["Search_Config"]["Search_threshold"])
{
_config.edgeDet.Search_threshold = value_f["form"]["Search_Config"]["Search_threshold"].asInt();
}
if (value_f["form"]["Detect_Config"]["Det_threshold"])
{
_config.edgeDet.Det_threshold = value_f["form"]["Detect_Config"]["Det_threshold"].asInt();
}
if (value_f["form"]["Detect_Config"]["Det_Range"])
{
_config.edgeDet.Det_Range = value_f["form"]["Detect_Config"]["Det_Range"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Widht_min"])
{
_config.edgeDet.QX_Widht_min = value_f["form"]["Detect_Config"]["QX_Widht_min"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Widht_max"])
{
_config.edgeDet.QX_Widht_max = value_f["form"]["Detect_Config"]["QX_Widht_max"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Height_min"])
{
_config.edgeDet.QX_Height_min = value_f["form"]["Detect_Config"]["QX_Height_min"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Height_max"])
{
_config.edgeDet.QX_Height_max = value_f["form"]["Detect_Config"]["QX_Height_max"].asInt();
}
///============================================
if (value_f["form"]["Jiao_Config"]["LU_Jiao"])
if (value_f["form"]["Det_Config"]["pin_x_offset"])
{
_config.edgeDet.queJiao_LU_Open = value_f["form"]["Jiao_Config"]["LU_Jiao"].asBool();
_config.pinDet.pin_x_offset = value_f["form"]["Det_Config"]["pin_x_offset"].asFloat();
}
if (value_f["form"]["Jiao_Config"]["RU_Jiao"])
if (value_f["form"]["Det_Config"]["pin_y_offset"])
{
_config.edgeDet.queJiao_RU_Open = value_f["form"]["Jiao_Config"]["RU_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["LD_Jiao"])
{
_config.edgeDet.queJiao_LD_Open = value_f["form"]["Jiao_Config"]["LD_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["RD_Jiao"])
{
_config.edgeDet.queJiao_RD_Open = value_f["form"]["Jiao_Config"]["RD_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["Jiao_Width"])
{
_config.edgeDet.queJiao_width = value_f["form"]["Jiao_Config"]["Jiao_Width"].asInt();
}
if (value_f["form"]["Jiao_Config"]["Jiao_Height"])
{
_config.edgeDet.queJiao_height = value_f["form"]["Jiao_Config"]["Jiao_Height"].asInt();
}
if (value_f["form"]["Draw_Config"]["Open"])
{
_config.edgeDet.bDrawRoi = value_f["form"]["Draw_Config"]["Open"].asBool();
}
// 2、读取区域点
{
auto value_region = value_f["form"]["Draw_Config"]["Edge_ROI"];
if (value_region.isArray())
{
for (int idx = 0; idx < value_region.size(); idx++)
{
cv::Point p;
p.x = value_region[idx][0].asInt();
p.y = value_region[idx][1].asInt();
_config.edgeDet.region.emplace_back(p);
}
if (_config.edgeDet.region.size() > 0)
{
_config.edgeDet.draw_ROI = boundingRect(_config.edgeDet.region);
}
}
_config.pinDet.pin_y_offset = value_f["form"]["Det_Config"]["pin_y_offset"].asFloat();
}
if (value_f["form"]["otherConfig"]["bDrawResult"])
{
_config.edgeDet.bDrawResult = value_f["form"]["otherConfig"]["bDrawResult"].asBool();
_config.pinDet.bDrawResult = value_f["form"]["otherConfig"]["bDrawResult"].asBool();
}
}
else
{
_config.edgeDet.Init();
_config.pinDet.Init();
}
// _config.edgeDet.print("edgeDet");
// _config.pinDet.print("pinDet");
// getchar();
}
if ("Det_Image_Save" == strCode)
@ -984,7 +851,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{
_config.saveImg.Init();
}
// _config.edgeDet.print("edgeDet");
// _config.pinDet.print("pinDet");
// getchar();
}
if ("Big_NG" == strCode)
@ -995,131 +862,91 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
_config.bigNG.bOpen = value_f["isOpen"].asBool();
if (_config.bigNG.bOpen)
{
if (value_f["form"]["aotudian"]["open"])
if (value_f["form"]["PIN_PoSun"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_aotudian].bOpen = value_f["form"]["aotudian"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].bOpen = value_f["form"]["PIN_PoSun"]["open"].asBool();
}
if (value_f["form"]["aotudian"]["Area"])
if (value_f["form"]["PIN_PoSun"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_aotudian].fArea = value_f["form"]["aotudian"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].fArea = value_f["form"]["PIN_PoSun"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_aotudian].strname = "aotudian";
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].strname = "PIN_PoSun";
if (value_f["form"]["other"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_other].bOpen = value_f["form"]["other"]["open"].asBool();
}
if (value_f["form"]["other"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_other].fArea = value_f["form"]["other"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_other].strname = "other";
if (value_f["form"]["line"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_line].bOpen = value_f["form"]["line"]["open"].asBool();
}
if (value_f["form"]["line"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_line].fArea = value_f["form"]["line"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_line].strname = "line";
if (value_f["form"]["zangwu"]["open"])
if (value_f["form"]["PIN_QueShi"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_zangwu].bOpen = value_f["form"]["zangwu"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].bOpen = value_f["form"]["PIN_QueShi"]["open"].asBool();
}
if (value_f["form"]["zangwu"]["Area"])
if (value_f["form"]["PIN_QueShi"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_zangwu].fArea = value_f["form"]["zangwu"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].fArea = value_f["form"]["PIN_QueShi"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_zangwu].strname = "zangwu";
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].strname = "PIN_QueShi";
if (value_f["form"]["edge"]["open"])
if (value_f["form"]["BTB_DuanLie"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_edge].bOpen = value_f["form"]["edge"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].bOpen = value_f["form"]["BTB_DuanLie"]["open"].asBool();
}
if (value_f["form"]["edge"]["Area"])
if (value_f["form"]["BTB_DuanLie"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_edge].fArea = value_f["form"]["edge"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].fArea = value_f["form"]["BTB_DuanLie"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_edge].strname = "edge";
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].strname = "BTB_DuanLie";
if (value_f["form"]["ymhs"]["open"])
if (value_f["form"]["LianXi"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_ymhs].bOpen = value_f["form"]["ymhs"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].bOpen = value_f["form"]["LianXi"]["open"].asBool();
}
if (value_f["form"]["ymhs"]["Area"])
if (value_f["form"]["LianXi"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_ymhs].fArea = value_f["form"]["ymhs"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].fArea = value_f["form"]["LianXi"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_ymhs].strname = "ymhs";
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].strname = "LianXi";
if (value_f["form"]["dianzhuang"]["open"])
if (value_f["form"]["QueXi"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_dianzhuang].bOpen = value_f["form"]["dianzhuang"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].bOpen = value_f["form"]["QueXi"]["open"].asBool();
}
if (value_f["form"]["dianzhuang"]["Area"])
if (value_f["form"]["QueXi"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_dianzhuang].fArea = value_f["form"]["dianzhuang"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].fArea = value_f["form"]["QueXi"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_dianzhuang].strname = "dianzhuang";
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].strname = "QueXi";
if (value_f["form"]["posun"]["open"])
if (value_f["form"]["YiWu"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_posun].bOpen = value_f["form"]["posun"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].bOpen = value_f["form"]["YiWu"]["open"].asBool();
}
if (value_f["form"]["posun"]["Area"])
if (value_f["form"]["YiWu"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_posun].fArea = value_f["form"]["posun"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].fArea = value_f["form"]["YiWu"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_posun].strname = "posun";
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].strname = "YiWu";
if (value_f["form"]["xianwei"]["open"])
if (value_f["form"]["C_BianXing"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_xianwei].bOpen = value_f["form"]["xianwei"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].bOpen = value_f["form"]["C_BianXing"]["open"].asBool();
}
if (value_f["form"]["xianwei"]["Area"])
if (value_f["form"]["C_BianXing"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_xianwei].fArea = value_f["form"]["xianwei"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].fArea = value_f["form"]["C_BianXing"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_xianwei].strname = "xianwei";
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].strname = "C_BianXing";
if (value_f["form"]["shuizi"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_shuizi].bOpen = value_f["form"]["shuizi"]["open"].asBool();
}
if (value_f["form"]["shuizi"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_shuizi].fArea = value_f["form"]["shuizi"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_shuizi].strname = "shuizi";
if (value_f["form"]["danban"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_danban].bOpen = value_f["form"]["danban"]["open"].asBool();
}
if (value_f["form"]["danban"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_danban].fArea = value_f["form"]["danban"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_danban].strname = "danban";
if (value_f["form"]["fuchen"]["open"])
if (value_f["form"]["other"]["open"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_fuchen].bOpen = value_f["form"]["fuchen"]["open"].asBool();
_config.bigNG.qx[CONFIG_QX_NAME_other].bOpen = value_f["form"]["other"]["open"].asBool();
}
if (value_f["form"]["fuchen"]["Area"])
if (value_f["form"]["other"]["Area"])
{
_config.bigNG.qx[CONFIG_QX_NAME_cell_fuchen].fArea = value_f["form"]["fuchen"]["Area"].asFloat();
_config.bigNG.qx[CONFIG_QX_NAME_other].fArea = value_f["form"]["other"]["Area"].asFloat();
}
_config.bigNG.qx[CONFIG_QX_NAME_cell_fuchen].strname = "fuchen";
_config.bigNG.qx[CONFIG_QX_NAME_other].strname = "other";
}
else
{
_config.bigNG.Init();
}
// _config.edgeDet.print("edgeDet");
// _config.pinDet.print("pinDet");
// getchar();
}
return 0;

@ -423,6 +423,7 @@ int deal::preCheck()
{
continue;
}
pushImgNum++;
}
SetStatus_List(ThreadIdx, Thread_Status_READY);
GetImgNum++;
@ -458,7 +459,7 @@ int deal::preCheck()
std::shared_ptr<CheckResult> checkResult;
int re = m_pALLImgCheckAnalysisy->GetCheckReuslt(checkResult);
saveImg("/home/aidlux/BOE/CELL_AOI/testresult/", checkResult);
saveImg("/home/aidlux/BOE/ZB_SOCKET/testresult/", checkResult);
getresultNum++;
if (getresultNum == pushImgNum)
{
@ -804,14 +805,14 @@ void deal::ResultThread(int id)
// 存图
// std::string savepath = "/home/aidlux/BOE/Detsave/" + runConfig.filePath + "/";
// saveImg(savepath, dealResult);
saveImg("/home/aidlux/BOE/CELL_AOI/Detsave/", dealResult);
saveImg("/home/aidlux/BOE/ZB_SOCKET/Detsave/", dealResult);
}
{
// 存 检测统计 日志
mutex_DetResult_.lock();
m_DetResult.print(false);
std::string strlog = "/home/aidlux/BOE/CELL_AOI/ResultImg/";
std::string strlog = "/home/aidlux/BOE/ZB_SOCKET/ResultImg/";
if (m_strCurDate != "")
{
strlog += m_strCurDate;
@ -1167,7 +1168,12 @@ int deal::DetImg()
{
m_nReadThread_type = READ_THREAD_TYPE_READIMG;
StartThread(THREAD_RUN_Only_ReadImg);
preCheck();
// -8 循环执行:像 -f 批量一样,线程只启动一次,内部重复跑同一套图
do
{
preCheck();
usleep(10 * 1000);
} while (runConfig.bLoop);
return 0;
}
@ -1597,6 +1603,11 @@ int deal::LoadProductID(std::string strImgPath)
}
int deal::DelImg_Cell_ET()
{
// -8 循环执行:每次重新加载产品列表,重复跑同一批产品
if (runConfig.bLoop && runConfig.filePath != "")
{
LoadProductID(runConfig.filePath);
}
size_t totalSize = m_product_ID_List.size();
if (totalSize > 0)

@ -499,6 +499,7 @@ struct DealRunConfig
RUNTYPE_ det_Type = RUNTYPE_RUN_Pre; // 处理
std::string filePath = ""; // 处理文件路径 如果为空 处理当前的单张图片
bool bSaveProcessImg = false; // 是否中间图片图片
bool bLoop = false; // -8 循环执行(常驻)
void print(std::string str)
{
printf(">>>>>>>>>>>>>>> %s <<<<<<<<<<<<\n", str.c_str());

@ -85,6 +85,7 @@ int main(int argc, char *argv[])
cout << "*** 5、./test_JBL_Check -falign filepath num : 批量测试定位算法num 至多处理张数,结果:/home/aidlux/BOE/Align" << endl;
cout << "*** 6、./test_JBL_Check -rjson filepath: 单张复测filepath xx/xx/3A3K380001B1DK_20240408_152157_Main_0_2_L255" << endl;
cout << "*** 6、./test_JBL_Check -rjsonall filepath: 一套图复测filepath xx/xx/" << endl;
cout << "*** 7、./test_SOCKET -8: 循环执行程序(常驻),不加 -8 只执行一次" << endl;
cout << "******************************************************" << endl;
return 0;
@ -145,12 +146,21 @@ int main(int argc, char *argv[])
test.runConfig.print("config");
// getchar();
signal(SIGINT, handler);
test.start();
while (true)
// -8: 循环执行程序(常驻);默认:执行一次后退出
bool bLoop = false;
for (int i = 1; i < argc; i++)
{
usleep(10 * 1000);
if (string(argv[i]) == "-8")
{
bLoop = true;
break;
}
}
test.runConfig.bLoop = bLoop;
test.start();
return 0;
}

Loading…
Cancel
Save