liusiyang
/
BOE_ZB_BACKPLATE
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: liusiyang:ec5933dba1efc4631a5975bdc66cf2404c1437e5
Branches Tags
liusiyang:dev_lsy
liusiyang:main
..
compare: liusiyang:331da0fabd97344f8d342a9f91007b0d52311ebc
Branches Tags
liusiyang:dev_lsy
liusiyang:main

No commits in common. 'ec5933dba1efc4631a5975bdc66cf2404c1437e5' and '331da0fabd97344f8d342a9f91007b0d52311ebc' have entirely different histories.
ec5933dba1 ... 331da0fabd

10 changed files with 337 additions and 1026 deletions
Show Stats

58
AlgorithmModule/include/CheckUtil.hpp
Unescape View File

@ -26,22 +26,18 @@
#include <opencv2/opencv.hpp>
using namespace std;
// 掩膜主体（圆角矩形）外的凸起区域（如把手）的描述
// 掩膜主体（近似矩形）四周凸起（如把手）的描述
struct Mask_Protrusion_
{
int nCorner; // 就近角（产品主轴坐标系）：0 左上 1 右上 2 左下 3 右下
cv::Rect roi; // 凸起外接矩形（输入图坐标系，已裁剪到图像范围内）
cv::Point2f ptCenter; // 凸起质心（输入图坐标系）
float fAngle; // 边缘倾角（度，日志排查用）
float fLen; // 凸起外接矩形长边（像素）
float fDepth; // 凸起相对主体直边的最大伸出深度（像素）
float fArea; // 凸起面积（掩膜像素数）
float fFillRatio; // 凸起外接矩形内掩膜像素占比
int nSide; // 所在边：0 左 1 右 2 上 3 下
cv::Rect roi; // 凸起外接矩形（输入图坐标系，已裁剪到图像范围内）
float fLen; // 沿该边的长度（像素）
float fDepth; // 伸出主体的深度（像素）
float fArea; // 凸起面积（roi 内掩膜像素数）
float fFillRatio; // roi 内掩膜像素占比（用于判定是否"类似矩形块"）
Mask_Protrusion_()
{
nCorner = 0;
ptCenter = cv::Point2f(0.0f, 0.0f);
fAngle = 0.0f;
nSide = 0;
fLen = 0.0f;
fDepth = 0.0f;
fArea = 0.0f;
@ -82,36 +78,28 @@ public:
// 找图片的最大外轮廓
static std::vector<cv::Point> getLargestContourROI(const cv::Mat &binaryImg, bool &found);
// 从外轮廓掩膜(outer定位mask)中分离凸起区域（如把手）：
// 主体是圆角矩形、把手基本出现在四角附近：逐行/逐列扫描掩膜边界，为每条边缘搜索带内点数最多的直线；
// 掩膜中超出四条边缘(超过容差带)的像素按连通域切分成凸起区域（含就近角/质心/面积/深度/填充率）。
// binMask：掩膜（非零为前景，兼容 0/1 与 0/255）；protrusions：输出的凸起列表（按面积从大到小）
// 可调参数（应对实际情况）：
// nMinDepth：凸起最小深度(输入图像素；<=0 时按掩膜短边/150 自动取值，下限 6)
// 调大：只报明显外凸的把手，浅把手会漏检，可压住边缘毛刺/噪声；
// 调小：浅凸起与噪声都易报出(误报变多)。mask 由模型输出放大而来时直边带量化台阶
// (台阶高≈量化步长)，建议取 2 个量化步长左右（调用方见 CheckHandleByBigMask）。
// nMinArea：凸起最小面积(输入图像素²；<=0 时按 nMinDepth² 自动取值)
// 调大：小碎块被过滤，把手很小或被遮挡一部分时可能漏检；
// 调小：碎块残留为候选的几率变大(仍会被 nMinDepth 再过滤一遍)。
// nEdgeMargin：边缘外扩量(输入图像素；<=0 时自动取“最小深度的一半”)
// 把四条边缘线整体向外推该距离后再判凸起，等效于把凸起区域相应减小：
// 调大：边缘顺边毛刺/线条偏差被吞掉，凸起区域更小更干净；过大时浅把手漏检；
// 调小：更灵敏，但边缘毛刺容易连进凸起区域。
// 边缘拟合的细节参数(带宽容差/斜率上限)见 FitEdgeLine 注释。
// pBodyQuad：可选输出，拟合出的主体四边形(左上/右上/右下/左下，输入图坐标)，仅 -s 存图观察用
// 抠出掩膜四周的凸起：主体近似矩形，凸起在该边表现为边界值的一次突变(进入)与一次反向突变(离开)
// binMask：掩膜（非零为前景，兼容 0/1 与 0/255）；protrusions：输出的凸起列表
// 参数调整影响（nJumpThresh/nMinRun/nMinDepth 为输入图像素，内部按降采样比例 nScale(1/2/4) 缩小后使用；nMaxRun 不换算，直接用工作图像素）：
// nJumpThresh：边界突变阈值，相邻行/列边界值一次变化超过它才算"进入/离开"台阶；
// 调大：只认陡峭台阶，圆角/噪声/锯齿被过滤，过大时边缘圆滑的真把手会漏检；
// 调小：敏感，噪声/斜边易触发假配对（可能形成跨度很大的假凸起）。
// nMinRun：凸起最小长度（"离开"突变搜索从 s+nMinRun 开始；profile 比它短的边直接跳过）；
// 调大：短凸起被排除，若大于真把手长度，真"离开"突变被跳过、会配到更远突变 → 出更大的框；
// 调小：小抖动/碎框变多。
// nMinDepth：凸起最小深度，区间内 ≥80% 采样点相对首尾连线基线外偏 ≥ 它（且最大外偏 ≥ 它）才保留（滤斜边/圆角）；
// 调大：只保留明显凸出的，浅凸起漏检，可挡"浅而长"的假配对；
// 调小：浅波纹/边缘抖动也过检，假凸起变多。
// nMaxRun：凸起最大长度（框沿边长度的硬上限）；<=0 时取 max(100, 掩膜短边/3)（工作图像素）；
// 调大：允许远距离突变配对 → 会出"覆盖整边"的大框；调小：框被截短，小于真把手长度时真把手漏检。
// 返回：0 成功、1 掩膜为空、2 无有效前景
static int GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protrusion_> &protrusions,
int nMinDepth = 0, int nMinArea = 0, std::vector<cv::Point2f> *pBodyQuad = NULL,
int nEdgeMargin = 0);
int nJumpThresh = 40, int nMinRun = 40, int nMinDepth = 40, int nMaxRun = 0);
static std::string GetRectString(cv::Rect rect);
//创建目录
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);

34
AlgorithmModule/include/ImgCheckAnalysisy.hpp
Unescape View File

@ -50,6 +50,19 @@ enum AT_THRESHOLD_TYPE_
// 全局静态变量， 记录图像灰度值异常累计数量
static int g_nImgBrightnessErrorCount = 0;
// 把手候选：bigmask 凸起 + 实测特征（面积/填充率，仅供日志排查）
struct Handle_Candidate_
{
Mask_Protrusion_ protr; // 凸起几何信息（roi / 沿边长度 / 深度 / 面积 / 填充率）
int nLen; // 沿边长度（像素）
int nDepth; // 垂直深度（像素）
Handle_Candidate_()
{
nLen = 0;
nDepth = 0;
}
};
// 单个把手区域的判定结果
struct Handle_Region_Result_
{
@ -77,17 +90,11 @@ struct Support_Draw_Info_
float fDist; // 实测距离（原图像素）
float fStandard; // 标准距离（原图像素）
bool bExceed; // |fDist-fStandard| 超限差(x_offset) -> 红色
cv::Point2f ptEdge; // 连线端点：所计算边缘上、支架中心行/列处的点（原图坐标）
cv::Point2f ptEdgeA; // 所计算边缘线段端点A（原图坐标）
cv::Point2f ptEdgeB; // 所计算边缘线段端点B（原图坐标）
Edge_Draw_()
{
fDist = 0.0f;
fStandard = 0.0f;
bExceed = false;
ptEdge = cv::Point2f(0.0f, 0.0f);
ptEdgeA = cv::Point2f(0.0f, 0.0f);
ptEdgeB = cv::Point2f(0.0f, 0.0f);
}
};
bool bValid; // 本次是否有效计算出支架偏移几何
@ -187,19 +194,13 @@ private:
bool TryReuseAlignFromSource(std::string &strSrcCamera, std::string &strSrcChannel, int &nWaitMs);
// 发布本图定位结果/失败标记(供同产品其它相机复用)
void PublishAlignShare(bool bSucc);
// 用 outer 定位 mask(bigmask) 检测把手：拟合主体上/下/左/右四条边缘，
// 把边缘外的凸起按连通域分离为把手候选（见 CheckUtil::GetMaskProtrusions），
// 再与参数的把手区域匹配；某个区域附近找不到匹配凸起 → 该区域把手缺失
// -s(存过程图)时输出 {通道}_handle_det.jpg：绿色四边形=拟合主体、红框=凸起(带编号/角/深度)、
// 蓝框=参数把手区域、绿框=匹配到的把手，便于从图像排查
// 用 bigmask 检测把手（bigmask 主体近似矩形，把手是四周凸起的矩形块）
int CheckHandleByBigMask(const cv::Mat &bigmask);
// 标签检测(独立步骤)：用 (图像 + bigmask) 跑 Tag_Loc 模型，检出结果存 m_tag_roiList
// 明场传自身 bigmask；暗场不做定位模型，传复用明场的 bigmask
int CheckTagByBigMask(const cv::Mat &img, const cv::Mat &bigmask);
// 在某个把手区域附近找宽高匹配的凸起：返回凸起在 candList 中的下标（-1=没找到）
// 匹配参数(搜索范围 handle_search_ratio、大小比区间 handle_size_min/handle_size_max)
// 可 JSON(Handle_Detect.form.handle_param)配置，未配置时用 cpp 顶部宏默认值，见 ImgCheckAnalysisy.cpp 参数注释
int MatchHandleRegion(const std::vector<Mask_Protrusion_> &candList, const std::vector<bool> &usedList,
int MatchHandleRegion(const std::vector<Handle_Candidate_> &candList, const std::vector<bool> &usedList,
const cv::Rect &boxRegion, cv::Rect &roiHandle);
// 计算产品尺寸
int CalProductSize();
@ -380,10 +381,9 @@ private:
cv::RotatedRect m_inner_rroi;
std::vector<cv::RotatedRect> m_tag_roiList;
// 把手检测结果（从 outer 定位 mask 分离的凸起区域 + 各把手区域判定结果）
std::vector<Mask_Protrusion_> m_HandleProtrusionList; // 分离出的凸起区域（把手候选：roi/质心/深度/就近角等）
// 把手检测结果（bigmask 四周凸起 + 各把手区域判定结果）
std::vector<Handle_Candidate_> m_HandleCandList; // 从 bigmask 四周抠出的凸起候选 + 实测特征
std::vector<Handle_Region_Result_> m_HandleRegionResultList; // 各把手区域（最多4个）的判定结果
std::vector<cv::Point2f> m_HandleBodyQuad; // 拟合出的主体四边形(TL/TR/BR/BL，原图坐标；支架偏移检测复用其四边抗凸起)
bool m_bHandleDetSucc; // 本次是否完成把手检测
bool m_bHandleFound; // 所有非空把手区域是否都找到了把手
bool m_bHandleExpect; // 是否开启了把手缺失检测（且有非空把手区域）

546
AlgorithmModule/src/CheckUtil.cpp
Unescape View File

@ -19,8 +19,6 @@
#include <stdlib.h>
#include <fstream>
#include <thread>
#include <algorithm>
#include <cmath>
#include "snowflake.hpp"
int _sysmkdir_2(const std::string &dir)
@ -91,9 +89,9 @@ std::string CheckUtil::getCurTimeHMS()
int millisec = tv.tv_usec / 1000; // 微秒转毫秒
std::ostringstream oss;
oss << std::setfill('0') << std::setw(2) << time_info->tm_hour << "-"
<< std::setfill('0') << std::setw(2) << time_info->tm_min << "-"
<< std::setfill('0') << std::setw(2) << time_info->tm_sec << "-"
oss << std::setfill('0') << std::setw(2) << time_info->tm_hour << ":"
<< std::setfill('0') << std::setw(2) << time_info->tm_min << ":"
<< std::setfill('0') << std::setw(2) << time_info->tm_sec << "."
<< std::setfill('0') << std::setw(3) << millisec;
return oss.str(); // 返回格式 "HH:MM:SS.mmm"
@ -503,32 +501,6 @@ 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));
@ -722,144 +694,8 @@ cv::Point2f CheckUtil::transformPoint(const cv::Point2f &point, const cv::Mat &t
return cv::Point2f(result_mat.at<double>(0), result_mat.at<double>(1));
}
// 拟合边缘直线：val ≈ fK * idx + fB（点集为 (扫描序号, 边界值)）
// 直边检测：在 |k| <= fMaxSlope 的斜率范围内搜索“带宽 ±fTol 内点数最多”的直线：
// 主体直边段的点最多且共线 → 被选中；把手段(点数更少)、角部过渡/另一侧边缘
// (斜率超出限制)等都不会获胜。随后在带内点集上做最小二乘精修(两轮收紧容差)。
// 可调参数(应对实际情况)：
// fTol：带宽容差(工作图像素)。调大→主体边缘带变宽，浅把手更容易被并入主体(漏检)、
// 但更能压住量化台阶毛刺；调小→台阶噪声可能分裂支撑或拟合到非主体结构。
// 默认由调用方按“量化台阶+2px”传入(见 GetMaskProtrusions 第 5 步)。
// fMaxSlope：直线搜索斜率上限。调大→允许产品倾斜更大；过大时角部斜过渡段可能
// 被当成直边；调小→产品倾斜稍大时拟合失败(退回常量线)。
// 点集为空返回 false；点太少/无有效直线时退回常量线(值取中位数)
static bool FitEdgeLine(const std::vector<cv::Point2f> &pts, double fTol, double fMaxSlope, double &fK, double &fB)
{
if (pts.empty())
{
return false;
}
// 常量线兜底：值取中位数
fK = 0.0;
{
std::vector<float> valList;
valList.reserve(pts.size());
for (size_t i = 0; i < pts.size(); i++)
{
valList.push_back(pts[i].y);
}
std::nth_element(valList.begin(), valList.begin() + valList.size() / 2, valList.end());
fB = (double)valList[valList.size() / 2];
}
if (pts.size() < 16)
{
return true; // 点太少：用常量线兜底
}
// 1、粗搜索：斜率网格 × 抽样锚点，取带内点数最多的直线
int nBestCnt = -1;
double fBestK = 0.0;
double fBestB = fB;
const size_t nStride = std::max<size_t>(1, pts.size() / 64);
auto fnCount = [&](double fk, double fb) -> int {
int nCnt = 0;
for (size_t i = 0; i < pts.size(); i++)
{
if (std::fabs((double)pts[i].y - (fk * pts[i].x + fb)) <= fTol)
{
nCnt++;
}
}
return nCnt;
};
const int nCoarseN = (int)(fMaxSlope / 0.03 + 0.5); // 斜率粗网格：±nCoarseN×0.03
for (int nk = -nCoarseN; nk <= nCoarseN; nk++)
{
double fk = nk * 0.03;
for (size_t i = 0; i < pts.size(); i += nStride)
{
double fb = (double)pts[i].y - fk * (double)pts[i].x;
int nCnt = fnCount(fk, fb);
if (nCnt > nBestCnt)
{
nBestCnt = nCnt;
fBestK = fk;
fBestB = fb;
}
}
}
// 2、细搜索：在粗搜索最优斜率附近收紧网格
for (int nk = -6; nk <= 6; nk++)
{
double fk = fBestK + nk * 0.005;
for (size_t i = 0; i < pts.size(); i += nStride)
{
double fb = (double)pts[i].y - fk * (double)pts[i].x;
int nCnt = fnCount(fk, fb);
if (nCnt > nBestCnt)
{
nBestCnt = nCnt;
fBestK = fk;
fBestB = fb;
}
}
}
// 3、带内点最小二乘精修（两轮收紧容差）
fK = fBestK;
fB = fBestB;
double fUseTol = fTol;
for (int nIter = 0; nIter < 2; nIter++)
{
std::vector<cv::Point2f> inl;
inl.reserve(pts.size());
for (size_t i = 0; i < pts.size(); i++)
{
if (std::fabs((double)pts[i].y - (fK * pts[i].x + fB)) <= fUseTol)
{
inl.push_back(pts[i]);
}
}
if (inl.size() < 8)
{
break;
}
cv::Vec4f line;
cv::fitLine(inl, line, cv::DIST_L2, 0, 1e-3, 1e-3);
if (std::fabs((double)line[0]) > 1e-6)
{
fK = (double)line[1] / (double)line[0];
fB = (double)line[3] - fK * (double)line[2];
}
fUseTol = std::max(3.0, fUseTol * 0.5);
}
return true;
}
// 从外轮廓掩膜(outer定位mask，如bigmask)中分离凸起区域（如把手）：
// 产品主体是圆角矩形、把手基本出现在四角附近，把手在掩膜上表现为超出主体四条边缘的外凸块：
// 1、取最大连通域为主体；
// 2、逐行/逐列扫描主体边界，得到 左/右(x=f(y))、上/下(y=f(x)) 四条边缘的边界点集；
// 3、对每条边缘做直线拟合(见 FitEdgeLine：取带内点数最多的直线，允许产品小角度倾斜)；
// 4、掩膜中超出四条边缘(超过容差带)的像素按连通域切分成凸起区域，
// 并按质心所在象限给出就近角(0 左上 1 右上 2 左下 3 右下)；深度/面积不足的量化毛刺被过滤。
// 可调参数（应对实际情况）：
// nMinDepth：凸起最小深度(输入图像素；<=0 时按掩膜短边/150 自动取值，下限 6)
// 调大：只报明显外凸的把手，浅把手会漏检，可压住边缘毛刺/噪声；
// 调小：浅凸起与噪声都易报出(误报变多)。mask 由模型输出放大而来时直边带量化台阶
// (台阶高≈量化步长)，建议取 2 个量化步长左右（调用方见 CheckHandleByBigMask）。
// nMinArea：凸起最小面积(输入图像素²；<=0 时按 nMinDepth² 自动取值)
// 调大：小碎块被过滤，把手很小或被遮挡一部分时可能漏检；
// 调小：碎块残留为候选的几率变大(仍会被 nMinDepth 再过滤一遍)。
// nEdgeMargin：边缘外扩量(输入图像素；<=0 时自动取“最小深度的一半”)
// 把四条边缘线整体向外推该距离后再判凸起，等效于把凸起区域相应减小：
// 调大：边缘顺边毛刺/线条偏差被吞掉，凸起区域更小更干净；过大时浅把手漏检；
// 调小：更灵敏，但边缘毛刺容易连进凸起区域。
// 边缘拟合的细节参数(带宽容差/斜率上限)见 FitEdgeLine 注释。
// pBodyQuad：可选输出，拟合出的主体四边形(左上/右上/右下/左下，输入图坐标)，仅 -s 存图观察用
// 返回：0 成功、1 掩膜为空、2 无有效前景
int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protrusion_> &protrusions,
int nMinDepth, int nMinArea, std::vector<cv::Point2f> *pBodyQuad, int nEdgeMargin)
int nJumpThresh, int nMinRun, int nMinDepth, int nMaxRun)
{
protrusions.clear();
if (binMask.empty())
@ -880,17 +716,7 @@ int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protr
cv::Mat maskFull;
cv::threshold(gray, maskFull, 0, 255, cv::THRESH_BINARY);
// 参数默认值按输入图尺度取
if (nMinDepth <= 0)
{
nMinDepth = std::max(6, std::min(maskFull.cols, maskFull.rows) / 150);
}
if (nMinArea <= 0)
{
nMinArea = std::max(64, nMinDepth * nMinDepth);
}
// 2、大掩膜先降采样再分析：凸起尺寸远大于降采样误差，可显著降低耗时
// 1.1 大掩膜先降采样再分析：凸起尺寸远大于降采样误差，可显著降低耗时
int nScale = 1;
while (nScale < 4 && std::max(maskFull.cols, maskFull.rows) / nScale > 2000)
{
@ -905,11 +731,12 @@ int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protr
{
mask = maskFull;
}
// 阈值按比例换算到工作图尺度
const int nMinDepthWork = std::max(2, nMinDepth / nScale);
const int nMinAreaWork = std::max(4, nMinArea / (nScale * nScale));
// 阈值按降采样比例换算到工作图尺度
nJumpThresh = std::max(2, nJumpThresh / nScale);
nMinRun = std::max(3, nMinRun / nScale);
nMinDepth = std::max(2, nMinDepth / nScale);
// 3、只保留最大连通域作为主体（过滤背景杂物）
// 2、只保留最大连通域，避免背景杂物参与边界统计
cv::Mat labels, stats, centroids;
int nLabels = cv::connectedComponentsWithStats(mask, labels, stats, centroids, 8, CV_32S);
if (nLabels <= 1)
@ -927,6 +754,8 @@ int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protr
nMainIdx = i;
}
}
// 3、裁剪到主体外接矩形，缩小后续扫描范围
cv::Rect boxMain(stats.at<int>(nMainIdx, cv::CC_STAT_LEFT), stats.at<int>(nMainIdx, cv::CC_STAT_TOP),
stats.at<int>(nMainIdx, cv::CC_STAT_WIDTH), stats.at<int>(nMainIdx, cv::CC_STAT_HEIGHT));
boxMain &= cv::Rect(0, 0, mask.cols, mask.rows);
@ -934,216 +763,201 @@ int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protr
{
return 2;
}
cv::Mat mainMask;
cv::compare(labels(boxMain), nMainIdx, mainMask, cv::CMP_EQ); // 主体连通域(0/255)
const int H = boxMain.height;
const int W = boxMain.width;
// 4、逐行/逐列扫描主体边界，收集四条边缘的边界点集（工作图坐标）
std::vector<cv::Point2f> ptsL, ptsR, ptsT, ptsB;
ptsL.reserve(H);
ptsR.reserve(H);
ptsT.reserve(W);
ptsB.reserve(W);
for (int y = 0; y < H; y++)
cv::Mat sub = (labels(boxMain) == nMainIdx); // 0/255
const int H = sub.rows;
const int W = sub.cols;
if (nMaxRun <= 0)
{
const uchar *p = mainMask.ptr<uchar>(y);
int nXL = -1;
int nXR = -1;
for (int x = 0; x < W; x++)
{
if (p[x]) { nXL = x; break; }
}
for (int x = W - 1; x >= 0; x--)
{
if (p[x]) { nXR = x; break; }
}
if (nXL >= 0)
{
ptsL.emplace_back((float)(y + boxMain.y), (float)(nXL + boxMain.x)); // (行号, 左边界的x)
}
if (nXR >= 0)
{
ptsR.emplace_back((float)(y + boxMain.y), (float)(nXR + boxMain.x)); // (行号, 右边界的x)
}
}
for (int x = 0; x < W; x++)
{
int nYT = -1;
int nYB = -1;
for (int y = 0; y < H; y++)
{
if (mainMask.ptr<uchar>(y)[x]) { nYT = y; break; }
}
for (int y = H - 1; y >= 0; y--)
{
if (mainMask.ptr<uchar>(y)[x]) { nYB = y; break; }
}
if (nYT >= 0)
{
ptsT.emplace_back((float)(x + boxMain.x), (float)(nYT + boxMain.y)); // (列号, 上边界的y)
}
if (nYB >= 0)
{
ptsB.emplace_back((float)(x + boxMain.x), (float)(nYB + boxMain.y)); // (列号, 下边界的y)
}
nMaxRun = std::max(100, std::min(H, W) / 3);
}
// 5、拟合四条边缘直线：左/右 x=f(y)、上/下 y=f(x)
// 直边判定：|k|<=0.6(近轴对齐)且带内(±fTol)点数最多的直线；fTol 覆盖量化台阶+网格误差
const int nFitStep = std::max(1, nMinDepthWork / 2); // 量化台阶估计(工作图)
// nExp：边缘外扩量(工作图像素)。显式给定(nEdgeMargin>0)时把边缘线整体向外推该距离，
// 等效于减小凸起区域；未给定时按最小深度的一半自动取值
const int nExp = (nEdgeMargin > 0) ? std::max(1, nEdgeMargin / nScale) : nFitStep;
const double fTol = std::max(6.0, (double)(nFitStep + 2));
double fKL = 0, fBL = 0, fKR = 0, fBR = 0, fKT = 0, fBT = 0, fKB = 0, fBB = 0;
if (!FitEdgeLine(ptsL, fTol, 0.6, fKL, fBL) || !FitEdgeLine(ptsR, fTol, 0.6, fKR, fBR) ||
!FitEdgeLine(ptsT, fTol, 0.6, fKT, fBT) || !FitEdgeLine(ptsB, fTol, 0.6, fKB, fBB))
// 4、逐边抠凸起：
// 主体近似矩形，矩形边上的凸起会让该边的"边界值"先突变到外侧(进入凸起)、再突变回主体(离开凸起)；
// 区间内的边界值相对"首尾边界值线性插值"得到的基线持续外偏，即判定为一个凸起。
for (int nSide = 0; nSide < 4; nSide++)
{
return 2;
}
// 主体中心(工作图坐标)与边缘合理性检查
const float fXc = boxMain.x + W * 0.5f;
const float fYc = boxMain.y + H * 0.5f;
if ((float)(fKR * fYc + fBR) - (float)(fKL * fYc + fBL) < 4.0f ||
(float)(fKB * fXc + fBB) - (float)(fKT * fXc + fBT) < 4.0f)
{
return 2;
}
// 可选输出：主体四边形(四角=相邻两条边缘直线的交点)，供 -s 存图观察拟合效果；
// 左/右边缘: x = k*y + b；上/下边缘: y = k*x + b，联立求交(行列式≈0 说明两线平行，放弃)
if (pBodyQuad != NULL)
{
pBodyQuad->clear();
auto fnCross = [](double fkX, double fbX, double fkY, double fbY, cv::Point2f &pt) -> bool {
double fDet = 1.0 - fkX * fkY;
if (std::fabs(fDet) < 1e-6)
const bool bRowScan = (nSide < 2); // 左右边按行扫描，上下边按列扫描
const int nLine = bRowScan ? H : W; // 扫描的行数/列数
const int nDir = (nSide == 0 || nSide == 2) ? 1 : -1; // 凸起内边界值变小(左侧/上侧)取 +1，变大取 -1
// 4.1 从每条 行/列 的外侧向内找第一个前景像素，得到该边的边界值 profile
std::vector<int> posList; // 有前景的行号/列号
std::vector<int> valList; // 对应的边界值
posList.reserve(nLine);
valList.reserve(nLine);
for (int i = 0; i < nLine; i++)
{
int nV = -1;
if (nSide == 0) // 左：自左向右
{
const uchar *p = sub.ptr<uchar>(i);
for (int x = 0; x < W; x++)
{
if (p[x])
{
nV = x;
break;
}
}
}
else if (nSide == 1) // 右：自右向左
{
const uchar *p = sub.ptr<uchar>(i);
for (int x = W - 1; x >= 0; x--)
{
if (p[x])
{
nV = x;
break;
}
}
}
else if (nSide == 2) // 上：自上向下
{
return false;
for (int y = 0; y < H; y++)
{
if (sub.ptr<uchar>(y)[i])
{
nV = y;
break;
}
}
}
pt.x = (float)((fbX + fkX * fbY) / fDet);
pt.y = (float)(fkY * pt.x + fbY);
return true;
};
cv::Point2f ptTL, ptTR, ptBR, ptBL;
if (fnCross(fKL, fBL, fKT, fBT, ptTL) && fnCross(fKR, fBR, fKT, fBT, ptTR) &&
fnCross(fKR, fBR, fKB, fBB, ptBR) && fnCross(fKL, fBL, fKB, fBB, ptBL))
else // 下：自下向上
{
for (int y = H - 1; y >= 0; y--)
{
if (sub.ptr<uchar>(y)[i])
{
nV = y;
break;
}
}
}
if (nV >= 0)
{
posList.push_back(i);
valList.push_back(nV);
}
}
const int n = (int)valList.size();
if (n < nMinRun + 2)
{
// 工作图坐标 -> 输入图坐标
pBodyQuad->push_back(cv::Point2f(ptTL.x * nScale, ptTL.y * nScale)); // 左上
pBodyQuad->push_back(cv::Point2f(ptTR.x * nScale, ptTR.y * nScale)); // 右上
pBodyQuad->push_back(cv::Point2f(ptBR.x * nScale, ptBR.y * nScale)); // 右下
pBodyQuad->push_back(cv::Point2f(ptBL.x * nScale, ptBL.y * nScale)); // 左下
continue;
}
}
// 6、凸起 = 超出四条边缘(超过容差带 nExp)的掩膜像素；容差带吸收边缘量化毛刺，
// 并可由 nEdgeMargin 显式加大(边缘线整体外推)来压制顺边毛刺/减小凸起区域
cv::Mat protrMask = cv::Mat::zeros(mask.size(), CV_8UC1);
for (int y = boxMain.y; y < boxMain.y + H; y++)
{
const uchar *pSrc = mainMask.ptr<uchar>(y - boxMain.y);
uchar *pDst = protrMask.ptr<uchar>(y);
const float fLineL = (float)(fKL * y + fBL) - nExp;
const float fLineR = (float)(fKR * y + fBR) + nExp;
for (int x = boxMain.x; x < boxMain.x + W; x++)
// 4.2 配对"进入/离开"突变，扣除该边上的凸起
int nUsedTo = -1; // 已统计过的凸起末端，避免同一个凸起重复输出
for (int s = 0; s + 1 < n; s++)
{
if (!pSrc[x - boxMain.x])
if (s <= nUsedTo)
{
continue;
}
if (x < fLineL || x > fLineR)
// 进入凸起：边界值朝外侧突变
if ((valList[s + 1] - valList[s]) * nDir >= -nJumpThresh)
{
pDst[x] = 255;
continue;
}
if (y < (float)(fKT * x + fBT) - nExp || y > (float)(fKB * x + fBB) + nExp)
// 离开凸起：在其后 nMaxRun 范围内找第一个反向突变
int e = -1;
for (int j = s + nMinRun; j + 1 < n && j - s <= nMaxRun; j++)
{
pDst[x] = 255;
if ((valList[j + 1] - valList[j]) * nDir > nJumpThresh)
{
e = j;
break;
}
}
if (e < 0)
{
continue;
}
}
}
// 7、按连通域切分成凸起区域：深度(相对四条边缘)/面积不足的毛刺过滤
cv::Mat labelsP, statsP, centP;
int nP = cv::connectedComponentsWithStats(protrMask, labelsP, statsP, centP, 8, CV_32S);
if (nP <= 1)
{
return 0; // 无凸起
}
// 4.3 区间内的边界值应持续超出"首尾边界值线性插值"得到的基线
const int kk = e - s;
int nDevOk = 0;
float fMaxDev = 0.0f;
int nLow = valList[s + 1];
int nHigh = valList[s + 1];
for (int i = 1; i <= kk; i++)
{
float fBase = valList[s] + (valList[e + 1] - valList[s]) * (float)i / (float)(kk + 1);
float fDev = (fBase - valList[s + i]) * nDir;
fMaxDev = std::max(fMaxDev, fDev);
if (fDev >= nMinDepth)
{
nDevOk++;
}
nLow = std::min(nLow, valList[s + i]);
nHigh = std::max(nHigh, valList[s + i]);
}
if (fMaxDev < nMinDepth)
{
continue;
}
// 凸起内大部分采样点都要明显外偏，避免把主体的斜边/圆角当成凸起
if (nDevOk < (int)(kk * 0.8f))
{
continue;
}
for (int i = 1; i < nP; i++)
{
int nArea = statsP.at<int>(i, cv::CC_STAT_AREA);
if (nArea < nMinAreaWork)
{
continue;
}
int nX = statsP.at<int>(i, cv::CC_STAT_LEFT);
int nY = statsP.at<int>(i, cv::CC_STAT_TOP);
int nW = statsP.at<int>(i, cv::CC_STAT_WIDTH);
int nH = statsP.at<int>(i, cv::CC_STAT_HEIGHT);
// 深度：组件像素相对四条边缘线的最大外伸（工作图像素）
float fDepth = 0.0f;
for (int yy = nY; yy < nY + nH; yy++)
{
const int *pLab = labelsP.ptr<int>(yy);
const float fLineL = (float)(fKL * yy + fBL);
const float fLineR = (float)(fKR * yy + fBR);
for (int xx = nX; xx < nX + nW; xx++)
// 4.4 计算凸起外接矩形（先算在 sub 图上的位置）
const int nLen = posList[e] - posList[s + 1] + 1; // 沿该边的长度
cv::Rect roiSub;
if (nSide == 0 || nSide == 2) // 左/上：外侧取小值，主体边缘取大值
{
if (pLab[xx] != i)
int nOut = nLow;
int nInner = std::max(valList[s], valList[e + 1]);
if (nSide == 0)
{
roiSub = cv::Rect(nOut, posList[s + 1], nInner - nOut + 1, nLen);
}
else
{
continue;
roiSub = cv::Rect(posList[s + 1], nOut, nLen, nInner - nOut + 1);
}
// 到四条边缘的最大外伸(在边缘内侧为负，取 0 忽略)
float fDev = std::max(fLineL - xx, xx - fLineR);
fDev = std::max(fDev, (float)(fKT * xx + fBT) - yy);
fDev = std::max(fDev, yy - (float)(fKB * xx + fBB));
fDepth = std::max(fDepth, fDev);
}
}
if (fDepth < nMinDepthWork)
{
continue;
}
else // 右/下：外侧取大值，主体边缘取小值
{
int nOut = nHigh;
int nInner = std::min(valList[s], valList[e + 1]);
if (nSide == 1)
{
roiSub = cv::Rect(nInner, posList[s + 1], nOut - nInner + 1, nLen);
}
else
{
roiSub = cv::Rect(posList[s + 1], nInner, nLen, nOut - nInner + 1);
}
}
roiSub &= cv::Rect(0, 0, W, H);
if (roiSub.width <= 0 || roiSub.height <= 0)
{
continue;
}
// 特征 + 坐标(工作图 -> 输入图)
Mask_Protrusion_ protr;
protr.roi = cv::Rect(nX * nScale, nY * nScale, nW * nScale, nH * nScale);
protr.roi &= cv::Rect(0, 0, binMask.cols, binMask.rows);
if (protr.roi.width <= 0 || protr.roi.height <= 0)
{
continue;
}
cv::Point2f ptCen;
if (centP.type() == CV_32F)
{
ptCen = centP.at<cv::Point2f>(i);
}
else
{
cv::Vec2d vCen = centP.at<cv::Vec2d>(i);
ptCen = cv::Point2f((float)vCen[0], (float)vCen[1]);
Mask_Protrusion_ protr;
protr.nSide = nSide;
// 从工作图尺度还原到输入图尺度
protr.roi = cv::Rect((roiSub.x + boxMain.x) * nScale, (roiSub.y + boxMain.y) * nScale,
roiSub.width * nScale, roiSub.height * nScale);
protr.roi &= cv::Rect(0, 0, binMask.cols, binMask.rows);
if (protr.roi.width <= 0 || protr.roi.height <= 0)
{
continue;
}
protr.fLen = (float)nLen * nScale;
protr.fDepth = fMaxDev * nScale;
int nMaskArea = cv::countNonZero(sub(roiSub));
protr.fArea = (float)nMaskArea * nScale * nScale;
protr.fFillRatio = (float)nMaskArea / (float)(roiSub.width * roiSub.height);
protrusions.push_back(protr);
nUsedTo = e; // 该凸起区间不再重复统计
}
protr.ptCenter = cv::Point2f(ptCen.x * nScale, ptCen.y * nScale);
// 就近角：按主体中心分象限 -> 0 左上 1 右上 2 左下 3 右下
bool bRight = ptCen.x > fXc;
bool bBottom = ptCen.y > fYc;
protr.nCorner = bBottom ? (bRight ? 3 : 2) : (bRight ? 1 : 0);
protr.fAngle = (float)(std::atan((fKL + fKR) * 0.5) * 180.0 / CV_PI); // 左右边缘平均倾角(度，相对垂直方向)
protr.fLen = (float)std::max(nW, nH) * nScale;
protr.fDepth = fDepth * nScale;
protr.fArea = (float)nArea * nScale * nScale;
protr.fFillRatio = (float)nArea / (float)(nW * nH);
protrusions.push_back(protr);
}
// 按面积从大到小排序（日志与匹配更稳定）
std::sort(protrusions.begin(), protrusions.end(),
[](const Mask_Protrusion_ &a, const Mask_Protrusion_ &b) { return a.fArea > b.fArea; });
return 0;
}

12
AlgorithmModule/src/ImageResultJudge.cpp
Unescape View File

@ -426,17 +426,15 @@ int ImageResultJudge::ResultJudge(std::shared_ptr<ImageAllResult> pImageResult)
}
}
std::string resultType = "OK";
// PIN_PianYi, 不受区域参数控制;
if (!Judge_Status && (config_qx_type == CONFIG_QX_NAME_cell_ZJ_PianYi || config_qx_type == CONFIG_QX_NAME_cell_ZJ_QueShi || config_qx_type == CONFIG_QX_NAME_cell_CGMo_QueShi))
// 标签缺陷（TBBQ）：检测到标签直接判 NG
if (config_qx_type == CONFIG_QX_NAME_cell_TBBQ)
{
pQxLog->AddCheckstr(PrintLevel_3, "qx info", " ZJ_PianYi | ZJ_QueShi | CGMo_QueShi: region param not used -> report NG by base judge");
Judge_Status = true;
bNG_Status = true;
Judge_Status = true;
}
std::string resultType = "OK";
if (!Judge_Status)
{
QX_info->result = QX_RESULT_TYPE_NoJduge;

413
AlgorithmModule/src/ImgCheckAnalysisy.cpp
Unescape View File

@ -22,33 +22,12 @@
// 待分类模型部署后，将 AI_CLASS_MODEL_ENABLE 置 1，即可恢复 AI_QX_Class_Thread 中的AI分类流程
#define AI_CLASS_MODEL_ENABLE 0
// 把手提取/判定参数（下面宏是“未配置 JSON 时”的默认值；现场可在参数 JSON 的 Handle_Detect.form.handle_param
// 下按注释标注的键名配置同名参数覆盖它们，按产品/现场情况调整，无需改代码重编译）：
// 提取：用 outer 定位 mask(bigmask) 拟合主体(圆角矩形)的上/下/左/右四条边缘，把边缘外的凸起按连通域分离为把手候选
// （见 CheckUtil::GetMaskProtrusions；产品主体是圆角矩形、把手基本出现在四角附近）
// 判定：每个非空的"把手区域"附近都应该有一个把手：凸起宽高与该区域外接矩形宽高的比值落在下面范围内才算匹配
// 调整影响：
// HANDLE_SIZE_MIN/MAX_RATIO（JSON: handle_size_min / handle_size_max）：凸起与参数把手区域外接矩形的宽高比允许区间
// 放宽(如 0.7~1.4)：把手尺寸/摆放差异大时不易漏检匹配，但可能让邻近错误凸起也匹配上；
// 收紧(如 0.9~1.1)：匹配更严格，把手实际尺寸与参数画得差异大时会误报"把手缺失"
// 把手判定参数：
// 每个非空的"把手区域"附近都应该有一个把手：凸起宽高与该区域外接矩形宽高的比值落在下面范围内才算匹配
#define HANDLE_SIZE_MIN_RATIO 0.8f
#define HANDLE_SIZE_MAX_RATIO 1.2f
// "附近"的搜索范围（JSON: handle_search_ratio）：把手区域外接矩形在宽/高方向各外扩该比例
// 调大：位置约束变松，产品摆放偏移大也不易漏(但可能匹配到别的凸起)；
// 调小：位置约束更严，偏移稍大就会判"附近没有把手"
// "附近"的搜索范围：把手区域外接矩形在宽/高方向各外扩该比例
#define HANDLE_NEAR_EXPAND_RATIO 5
// 把手提取：最小深度系数(× 定位模型量化步长)（JSON: handle_min_depth）
// 凸起区域算大了/过于灵敏(边缘顺边毛刺与把手连成一块、高度多算) → 调大(如 3~4)；
// 浅把手漏检 → 调小(如 1.5)。它同时决定：①凸起深度门槛；②边缘容差带(容差带=最小深度/2)
#define HANDLE_MIN_DEPTH_STEP_COEF 2
// 把手提取：最小面积系数(× 最小深度²)（JSON: handle_min_area）。碎块多 → 调大；小把手漏检 → 调小
#define HANDLE_MIN_AREA_COEF 2
// 把手提取：边缘外扩量系数(× 量化步长)（JSON: handle_edge_margin，0=按"最小深度一半"自动）：
// 把主体边缘线整体向外推，变相减小凸起区域。
// 凸起区域算大了(边缘顺边毛刺与把手连成一块、高度多算) → 调大(如 2~3)；
// 浅把手漏检/想更灵敏 → 调小。
// 注意：凸起区域会同步变小，匹配用的宽高比(HANDLE_SIZE_*_RATIO)会偏小，不宜调得过大
#define HANDLE_EDGE_MARGIN_STEP_COEF 3
// 把手缺失检测开关见 Base层 Function_Support_Det::bDetHandle（CheckConfigDefine.h）
// 分类映射配置文件（每行：label索引:缺陷名称；冒号后名称为该缺陷类型名称，行的顺序即缺陷类型索引）
@ -876,9 +855,7 @@ int ImgCheckAnalysisy::CheckRun()
m_pdetlog->bPrintStr = true;
}
// m_pdetlog->bPrintStr = true;
m_fImgage_Scale_X = m_pBasicConfig->fImage_Scale_x;
m_fImgage_Scale_Y = m_pBasicConfig->fImage_Scale_y;
m_pdetlog->AddCheckstr(PrintLevel_0, "1、basic Info", "---------------------------1、basic Info---------------------------------");
m_pdetlog->AddCheckstr(PrintLevel_0, "Version", "%s", GetVersion().c_str());
m_pdetlog->AddCheckstr(PrintLevel_0, "Updateconfig", "%d", m_bupdateconfig);
@ -1070,11 +1047,9 @@ int ImgCheckAnalysisy::CheckRun()
/* 检测支架偏移（bDetSupport 开关关闭时不做支架判定）
不使用参数绘制区域，结合两次定位的 mask 计算：
1、产品边缘：优先复用把手提取对 bigmask 做的"四边抗凸起拟合"主体四边形
（CheckHandleByBigMask -> GetMaskProtrusions；边缘上的凸起(把手等)不会把边缘带偏），
拟合不可用/无效时回退 bigmask 最大连通域外接矩形 rp（近似矩形，四周可能有凸起）
1、bigmask 最大连通域 = 产品区域 rp（近似矩形，四周可能有凸起）
2、smallmask 最大连通域 = 支架区域 rs（按定位裁剪区 m_outer_rroi 外接矩形映射回原图坐标）
3、按 edge_select 指定方向(left/right/up/down)计算 rs 中心到产品对应边缘的距离
3、按 edge_select 指定方向(left/right/up/down)计算 rs 中心到 rp 对应边缘的距离
4、计算值与标准值(x_standard/y_standard)做差取平均，平均差超过 offset(x_offset) → 偏移 */
{
Function_Support_Det &supportDet = m_pbaseCheckFunction->supportDet;
@ -1134,7 +1109,7 @@ int ImgCheckAnalysisy::CheckRun()
}
else
{
// rp 边缘(拟合不可用时的回退)：产品最大连通域的外接矩形（含凸起）
// rp 边缘：产品最大连通域的外接矩形（含凸起）
cv::Rect rpRect = cv::boundingRect(rpContour);
// rs 映射回原图坐标：smallmask 对应定位时裁剪的大轮廓区域(m_outer_rroi 外接矩形)，按比例映射
@ -1148,87 +1123,13 @@ int ImgCheckAnalysisy::CheckRun()
cvRound(rsSmallRect.width * fx),
cvRound(rsSmallRect.height * fy));
// 3、产品边缘：优先复用把手提取对 bigmask 做的"四边抗凸起拟合"主体四边形
// (CheckHandleByBigMask -> GetMaskProtrusions 输出)：边缘上的凸起(把手等)不会把边缘带偏；
// 拟合不可用/无效时回退到产品最大连通域外接矩形 rpRect(含凸起)
bool bFitQuad = false; // 是否用上了拟合主体四边形
float fDL = 0, fDR = 0, fDT = 0, fDB = 0; // 支架中心到产品左/右/上/下边缘的距离(原图像素，后乘缩放系数)
cv::Point2f ptEdgeArr[4]; // 连线端点(边缘线上)：0 left 1 right 2 up 3 down
cv::Point2f ptSegAArr[4]; // 边缘线段端点A
cv::Point2f ptSegBArr[4]; // 边缘线段端点B
// 3、rs 中心到 rp 上下左右边缘的距离
float fCx = rsRect.x + rsRect.width * 0.5f;
float fCy = rsRect.y + rsRect.height * 0.5f;
if (m_HandleBodyQuad.size() == 4)
{
// 四边形角点顺序：左上/右上/右下/左下；左/右边 x=k*y+b、上/下边 y=k*x+b(与 GetMaskProtrusions 约定一致)；
// 边长过小说明拟合退化，不用
const cv::Point2f &ptTL = m_HandleBodyQuad[0];
const cv::Point2f &ptTR = m_HandleBodyQuad[1];
const cv::Point2f &ptBR = m_HandleBodyQuad[2];
const cv::Point2f &ptBL = m_HandleBodyQuad[3];
if (fabs(ptBL.y - ptTL.y) > 2.0f && fabs(ptBR.y - ptTR.y) > 2.0f &&
fabs(ptTR.x - ptTL.x) > 2.0f && fabs(ptBR.x - ptBL.x) > 2.0f)
{
float fKL = (ptBL.x - ptTL.x) / (ptBL.y - ptTL.y); // 左边 x = k*y + b
float fBL = ptTL.x - fKL * ptTL.y;
float fKR = (ptBR.x - ptTR.x) / (ptBR.y - ptTR.y); // 右边 x = k*y + b
float fBR = ptTR.x - fKR * ptTR.y;
float fKT = (ptTR.y - ptTL.y) / (ptTR.x - ptTL.x); // 上边 y = k*x + b
float fBT = ptTL.y - fKT * ptTL.x;
float fKB = (ptBR.y - ptBL.y) / (ptBR.x - ptBL.x); // 下边 y = k*x + b
float fBB = ptBL.y - fKB * ptBL.x;
// 连线端点：取边缘线在支架中心行/列上的点；长度即中心到边缘的水平/垂直距离
float fXEdgeL = fKL * fCy + fBL;
float fXEdgeR = fKR * fCy + fBR;
float fYEdgeT = fKT * fCx + fBT;
float fYEdgeB = fKB * fCx + fBB;
fDL = fCx - fXEdgeL;
fDR = fXEdgeR - fCx;
fDT = fCy - fYEdgeT;
fDB = fYEdgeB - fCy;
// 拟合有效性：支架中心应位于四条拟合边内侧(四个方向距离均为正)，否则放弃拟合
if (fDL > 0 && fDR > 0 && fDT > 0 && fDB > 0)
{
ptEdgeArr[0] = cv::Point2f(fXEdgeL, fCy);
ptEdgeArr[1] = cv::Point2f(fXEdgeR, fCy);
ptEdgeArr[2] = cv::Point2f(fCx, fYEdgeT);
ptEdgeArr[3] = cv::Point2f(fCx, fYEdgeB);
ptSegAArr[0] = ptTL; ptSegBArr[0] = ptBL; // left：整条拟合左边
ptSegAArr[1] = ptTR; ptSegBArr[1] = ptBR; // right：整条拟合右边
ptSegAArr[2] = ptTL; ptSegBArr[2] = ptTR; // up：整条拟合上边
ptSegAArr[3] = ptBL; ptSegBArr[3] = ptBR; // down：整条拟合下边
bFitQuad = true;
}
}
}
if (!bFitQuad)
{
// 回退：产品区域外接矩形(含凸起)的四条边
fDL = fCx - rpRect.x;
fDR = (rpRect.x + rpRect.width) - fCx;
fDT = fCy - rpRect.y;
fDB = (rpRect.y + rpRect.height) - fCy;
ptEdgeArr[0] = cv::Point2f((float)rpRect.x, fCy);
ptEdgeArr[1] = cv::Point2f((float)(rpRect.x + rpRect.width), fCy);
ptEdgeArr[2] = cv::Point2f(fCx, (float)rpRect.y);
ptEdgeArr[3] = cv::Point2f(fCx, (float)(rpRect.y + rpRect.height));
ptSegAArr[0] = cv::Point2f((float)rpRect.x, (float)rpRect.y);
ptSegBArr[0] = cv::Point2f((float)rpRect.x, (float)(rpRect.y + rpRect.height));
ptSegAArr[1] = cv::Point2f((float)(rpRect.x + rpRect.width), (float)rpRect.y);
ptSegBArr[1] = cv::Point2f((float)(rpRect.x + rpRect.width), (float)(rpRect.y + rpRect.height));
ptSegAArr[2] = cv::Point2f((float)rpRect.x, (float)rpRect.y);
ptSegBArr[2] = cv::Point2f((float)(rpRect.x + rpRect.width), (float)rpRect.y);
ptSegAArr[3] = cv::Point2f((float)rpRect.x, (float)(rpRect.y + rpRect.height));
ptSegBArr[3] = cv::Point2f((float)(rpRect.x + rpRect.width), (float)(rpRect.y + rpRect.height));
}
// 像素 -> mm
fDL *= m_fImgage_Scale_X;
fDR *= m_fImgage_Scale_X;
fDT *= m_fImgage_Scale_Y;
fDB *= m_fImgage_Scale_Y;
float fDistArr[4] = {fDL, fDR, fDT, fDB}; // 顺序固定：0 left 1 right 2 up 3 down
float fDL = fCx - rpRect.x; // 到左边缘
float fDR = (rpRect.x + rpRect.width) - fCx; // 到右边缘
float fDT = fCy - rpRect.y; // 到上边缘
float fDB = (rpRect.y + rpRect.height) - fCy; // 到下边缘
// 4、按 edge_select 指定方向(left/right/up/down)取计算值，与标准值做差取平均，平均差超过 offset → 偏移
// left/right 用 x_standard，up/down 用 y_standard；offset 用 x_offset
@ -1240,26 +1141,26 @@ int ImgCheckAnalysisy::CheckRun()
for (size_t iselect = 0; iselect < supportDet.edge_select.size(); iselect++)
{
const std::string &strEdge = supportDet.edge_select[iselect];
int gi = -1; // 方向索引：0 left 1 right 2 up 3 down
float fDist = 0;
float fStandard = 0;
if (strEdge == "left")
{
gi = 0;
fDist = fDL;
fStandard = supportDet.x_standard;
}
else if (strEdge == "right")
{
gi = 1;
fDist = fDR;
fStandard = supportDet.x_standard;
}
else if (strEdge == "up")
{
gi = 2;
fDist = fDT;
fStandard = supportDet.y_standard;
}
else if (strEdge == "down")
{
gi = 3;
fDist = fDB;
fStandard = supportDet.y_standard;
}
else
@ -1267,7 +1168,6 @@ int ImgCheckAnalysisy::CheckRun()
continue;
}
float fDist = fDistArr[gi];
float fDiff = fabs(fDist - fStandard);
fSumDiff += fDiff;
nDiffNum++;
@ -1278,9 +1178,6 @@ int ImgCheckAnalysisy::CheckRun()
edgeDraw.fDist = fDist;
edgeDraw.fStandard = fStandard;
edgeDraw.bExceed = (fDiff > supportDet.x_offset);
edgeDraw.ptEdge = ptEdgeArr[gi];
edgeDraw.ptEdgeA = ptSegAArr[gi];
edgeDraw.ptEdgeB = ptSegBArr[gi];
m_SupportDrawInfo.edgeList.push_back(edgeDraw);
}
sprintf(strTmp, "%s(%.1f/%.1f) ", strEdge.c_str(), fDist, fStandard);
@ -1300,10 +1197,10 @@ int ImgCheckAnalysisy::CheckRun()
m_SupportDrawInfo.ptCenter = cv::Point2f(fCx, fCy);
m_pdetlog->AddCheckstr(PrintLevel_0, "支架检测",
"rp [%d %d %d %d] rs [%d %d %d %d] scale (%.4f %.4f) center (%.1f %.1f) edge %s quad %ld dL %.1f dR %.1f dT %.1f dB %.1f | select %s diff %s avgDiff %.1f limit %.1f ng %d",
"rp [%d %d %d %d] rs [%d %d %d %d] scale (%.4f %.4f) center (%.1f %.1f) dL %.1f dR %.1f dT %.1f dB %.1f | select %s diff %s avgDiff %.1f limit %.1f ng %d",
rpRect.x, rpRect.y, rpRect.width, rpRect.height,
rsRect.x, rsRect.y, rsRect.width, rsRect.height,
fx, fy, fCx, fCy, bFitQuad ? "fitquad" : "rpbox", (long)m_HandleBodyQuad.size(), fDL, fDR, fDT, fDB,
fx, fy, fCx, fCy, fDL, fDR, fDT, fDB,
strSelect.c_str(), strDiff.c_str(), fAvgDiff, supportDet.x_offset, bOffset);
if (bOffset)
@ -1419,35 +1316,10 @@ int ImgCheckAnalysisy::CheckRun()
{
m_tag_roiList.clear();
}
// 标签能量/灰阶差(hj)计算用掩膜：所有标签区域填白(与 blob 检测用 AIMaskImg 的口径一致)，
// 由 calc_blob_info_withstats 按“前景=标签区域、背景=外扩一圈”计算
long tagEnergy_s = CheckUtil::getcurTime();
cv::Mat tagMask;
if (!m_tag_roiList.empty() && !m_pImageAllResult->detImg.empty())
{
tagMask = cv::Mat::zeros(m_pImageAllResult->detImg.size(), CV_8UC1);
std::vector<std::vector<cv::Point>> tagPolys;
tagPolys.reserve(m_tag_roiList.size());
for (const auto &tagRoiMask : m_tag_roiList)
{
cv::Point2f ptfMask[4];
tagRoiMask.points(ptfMask);
std::vector<cv::Point> polyMask(4);
for (int k = 0; k < 4; k++)
{
polyMask[k] = cv::Point(cvRound(ptfMask[k].x), cvRound(ptfMask[k].y));
}
tagPolys.push_back(std::move(polyMask));
}
cv::fillPoly(tagMask, tagPolys, cv::Scalar(255));
}
for (const auto &tagRoi : m_tag_roiList)
{
// tag roi 在原图坐标系，按坐标映射转换到检测图(detImg)坐标系
// cv::Rect roi = MatAffineRect(m_matSrc2Det, tagRoi.boundingRect());
cv::Rect roi = tagRoi.boundingRect();
cv::Rect roi = MatAffineRect(m_matSrc2Det, tagRoi.boundingRect());
roi &= cv::Rect(0, 0, m_pImageAllResult->detImg.cols, m_pImageAllResult->detImg.rows);
if (roi.width <= 0 || roi.height <= 0)
{
@ -1464,16 +1336,6 @@ int ImgCheckAnalysisy::CheckRun()
float th = tagRoi.size.height;
temerror.flen = (tw > th ? tw : th) * m_fImgage_Scale_X;
temerror.fbreadth = (tw > th ? th : tw) * m_fImgage_Scale_Y;
// 标签区域的能量/灰阶差(hj)：与 blob 检测相同口径(前景=标签区域，背景=外扩一圈)
if (!tagMask.empty())
{
cv::Rect roiStat = roi;
cv::Scalar tagStat = calc_blob_info_withstats(m_pImageAllResult->detImg, tagMask, roiStat);
temerror.energy = (int)tagStat[1];
temerror.grayDis = (float)tagStat[2];
}
temerror.nconfig_qx_type = CONFIG_QX_NAME_cell_TBBQ;
temerror.qx_name = CONFIG_QX_NAME_Names[CONFIG_QX_NAME_cell_TBBQ];
temerror.result = QX_RESULT_TYPE_NG;
@ -1498,13 +1360,7 @@ int ImgCheckAnalysisy::CheckRun()
m_pDetResult->pQx_ErrorList->push_back(temerror);
m_pdetlog->AddCheckstr(PrintLevel_0, "Tag检测", "tag %d roi [%d %d %d %d] energy %d hj %.1f -> NG",
temerror.Idx, roi.x, roi.y, roi.width, roi.height, temerror.energy, temerror.grayDis);
}
if (!m_tag_roiList.empty())
{
long tagEnergy_e = CheckUtil::getcurTime();
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Tag", "tag energy calc use time %ld", tagEnergy_e - tagEnergy_s);
m_pdetlog->AddCheckstr(PrintLevel_0, "Tag检测", "tag %d roi [%d %d %d %d] -> NG", temerror.Idx, roi.x, roi.y, roi.width, roi.height);
}
}
@ -2256,8 +2112,6 @@ int ImgCheckAnalysisy::ConfigCheck(cv::Mat img)
int ImgCheckAnalysisy::AI_Detect_Thread(const cv::Mat &img, cv::Mat &ResultImg)
{
std::string cur_time_s = CheckUtil::getCurTimeHMS();
std::shared_ptr<AIModel_Base> pAIDet;
// printf("=====>>>>AI_Detect_Thread m_strCurDetChannel %s \n", m_strCurDetChannel.c_str());
bool bUseDarkModel = false;
@ -2367,12 +2221,12 @@ int ImgCheckAnalysisy::AI_Detect_Thread(const cv::Mat &img, cv::Mat &ResultImg)
if (m_pbaseCheckFunction->saveImg.bSaveAIDetImg && !ResultImg.empty())
{
std::string strSaveDir = "/home/aidlux/BOE/AI_Detect/" + DetImgInfo_shareP->strImgProductID + "/";
std::string strSaveDir = "/home/aidlux/BOE/AI_Detect/KK/" + DetImgInfo_shareP->strImgProductID + "/";
CheckUtil::CreateDir(strSaveDir);
std::string strSavePath_in = strSaveDir + cur_time_s + "_" + strCameraName + "_in.png";
std::string strSavePath_out = strSaveDir + cur_time_s + "_" + strCameraName + "_out.png";
CheckUtil::SaveImgAsync(strSavePath_in, m_CheckResult_shareP->cutSrcimg);
CheckUtil::SaveImgAsync(strSavePath_out, ResultImg);
std::string strSavePath_in = strSaveDir + m_strCurDetChannel + "_in.png";
std::string strSavePath_out = strSaveDir + m_strCurDetChannel + "_out.png";
cv::imwrite(strSavePath_in, inputImg);
cv::imwrite(strSavePath_out, ResultImg);
}
// 临时存图
@ -2693,47 +2547,56 @@ int ImgCheckAnalysisy::DrawResult_Step_1()
}
}
// 支架偏移检测绘制（受参数 bDrawSupport 控制，默认关闭）：
// 支架中心十字（绿=正常/红=偏移NG）+ 各方向"所计算的产品边缘"线段（抗凸起拟合直边，见 CheckRun 支架块）
// + 支架中心到该边缘的连线（连线长度=支架中心到所计算边缘的距离；绿=正常/红=超标准）+ 实测/标准(mm)文字
if (m_SupportDrawInfo.bValid && m_pbaseCheckFunction->supportDet.bDrawSupport && !m_CheckResult_shareP->resultimg.empty())
// 支架偏移检测绘制：支架中心十字（绿=正常/红=偏移NG）+ 支架到边缘的距离（绿=正常/红=超标准）
if (m_SupportDrawInfo.bValid && !m_CheckResult_shareP->resultimg.empty())
{
// 原图坐标 -> 检测图(裁剪) -> 结果图
auto srcToResult = [&](const cv::Point2f &pt) -> cv::Point {
cv::Point2f detPt = MatAffinePoint(m_matSrc2Det, pt);
return cv::Point(cvRound(detPt.x * fs_resize_x), cvRound(detPt.y * fs_resize_y));
};
// 支架中心：原图坐标 -> 检测图(裁剪) -> 结果图
cv::Point2f detPt = MatAffinePoint(m_matSrc2Det, m_SupportDrawInfo.ptCenter);
cv::Point pCenter(cvRound(detPt.x * fs_resize_x), cvRound(detPt.y * fs_resize_y));
// 支架中心十字：NG 红色 / 正常绿色
cv::Point pCenter = srcToResult(m_SupportDrawInfo.ptCenter);
cv::Scalar colorCross = m_SupportDrawInfo.bOffset ? cv::Scalar(0, 0, 255) : cv::Scalar(0, 255, 0);
colorCross = CheckUtil::GetDrawColor(m_CheckResult_shareP->resultimg, colorCross);
const int nCrossLen = 40; // 结果图上十字半长(px)
cv::line(m_CheckResult_shareP->resultimg, cv::Point(pCenter.x - nCrossLen, pCenter.y), cv::Point(pCenter.x + nCrossLen, pCenter.y), colorCross, 2);
cv::line(m_CheckResult_shareP->resultimg, cv::Point(pCenter.x, pCenter.y - nCrossLen), cv::Point(pCenter.x, pCenter.y + nCrossLen), colorCross, 2);
// 各方向：所计算边缘线段(抗凸起拟合直边/回退外接矩形边) + 中心到边缘点的连线(长度=点到所计算边缘) + 实测/标准文字
// 几何(边缘点/线段两端点)由 CheckRun 支架块算好存入 edgeDraw，此处只做坐标映射与绘制
// 支架到边缘的距离：中心 -> 产品区域对应边缘连线 + 实测/标准(像素)文字
char strTxt[64];
for (size_t i = 0; i < m_SupportDrawInfo.edgeList.size(); i++)
{
const Support_Draw_Info_::Edge_Draw_ &edgeDraw = m_SupportDrawInfo.edgeList[i];
cv::Point2f ptEdge = m_SupportDrawInfo.ptCenter;
if (edgeDraw.strEdge == "left")
{
ptEdge.x = (float)m_SupportDrawInfo.rpRect.x;
}
else if (edgeDraw.strEdge == "right")
{
ptEdge.x = (float)(m_SupportDrawInfo.rpRect.x + m_SupportDrawInfo.rpRect.width);
}
else if (edgeDraw.strEdge == "up")
{
ptEdge.y = (float)m_SupportDrawInfo.rpRect.y;
}
else if (edgeDraw.strEdge == "down")
{
ptEdge.y = (float)(m_SupportDrawInfo.rpRect.y + m_SupportDrawInfo.rpRect.height);
}
else
{
continue;
}
cv::Point pEdge = srcToResult(edgeDraw.ptEdge);
cv::Point pEdgeA = srcToResult(edgeDraw.ptEdgeA);
cv::Point pEdgeB = srcToResult(edgeDraw.ptEdgeB);
cv::Point2f detEdge = MatAffinePoint(m_matSrc2Det, ptEdge);
cv::Point pEdge(cvRound(detEdge.x * fs_resize_x), cvRound(detEdge.y * fs_resize_y));
// 超标准红色 / 正常绿色
cv::Scalar colorEdge = edgeDraw.bExceed ? cv::Scalar(0, 0, 255) : cv::Scalar(0, 255, 0);
colorEdge = CheckUtil::GetDrawColor(m_CheckResult_shareP->resultimg, colorEdge);
// 1、所计算边缘线段：标出参与计算的产品边缘（细线；抗凸起拟合直边/回退边）
cv::line(m_CheckResult_shareP->resultimg, pEdgeA, pEdgeB, colorEdge, 1);
// 2、中心 -> 边缘点连线：长度即支架中心到所计算边缘的距离
cv::line(m_CheckResult_shareP->resultimg, pCenter, pEdge, colorEdge, 2);
// 3、距离文字：实测/标准（mm）
// 距离文字：实测/标准（原图像素）
snprintf(strTxt, sizeof(strTxt), "%s %.0f/%.0f", edgeDraw.strEdge.c_str(), edgeDraw.fDist, edgeDraw.fStandard);
cv::putText(m_CheckResult_shareP->resultimg, strTxt,
cv::Point((pCenter.x + pEdge.x) / 2 + 6, (pCenter.y + pEdge.y) / 2 - 6),
@ -2912,7 +2775,7 @@ int ImgCheckAnalysisy::AI_Edge(const cv::Mat &img, cv::RotatedRect &outerRoi, cv
// 无条件赋值：Tag_Loc 未检出或 bDetTag 关闭(tagroi 为空)时清空，避免残留上一张图的标签
tagroiList = m_pEdge_Align_Result->tagroi;
/* 用 outer 定位 mask(bigmask) 分离凸起区域，检测把手是否缺失 */
/*使用m_pEdge_Align_Result->bigmask检测把手是否缺失*/
{
long handle_s = CheckUtil::getcurTime();
CheckHandleByBigMask(m_pEdge_Align_Result->bigmask);
@ -2922,23 +2785,19 @@ int ImgCheckAnalysisy::AI_Edge(const cv::Mat &img, cv::RotatedRect &outerRoi, cv
return re;
}
// 用 outer 定位 mask(bigmask) 检测把手（产品主体是圆角矩形、把手基本出现在四角附近）：
// 1、分离凸起区域：拟合主体上/下/左/右四条边缘，把边缘外的掩膜按连通域切分成凸起区域
// （提取细节见 CheckUtil::GetMaskProtrusions，含就近角/质心/面积/深度/填充率）
// 2、参数里每个非空的"把手区域"附近都应该有一个把手：在区域附近找凸起，
// 凸起宽高与区域外接矩形宽高相近（尺寸比区间见 handle_size_min/handle_size_max，可 JSON 配置）才算匹配
// 3、凸起本身不算 NG，只有"某个把手区域附近找不到匹配的凸起"才算把手缺失（NG 由 CheckRun 上报）
// 4、-s(存过程图)时输出 {通道}_handle_det.jpg：绿色四边形=拟合主体、红框=凸起(带编号/角/深度)、
// 蓝框=参数把手区域、绿框=匹配到的把手，便于从图像观察问题
// 5、拟合出的主体四边形存 m_HandleBodyQuad：支架偏移检测复用其四边(抗凸起)做测距与绘制
// 用 bigmask 检测把手：
// 1、bigmask 主体近似矩形，把手是主体四周凸起的"类矩形块"
// 2、把主体四周的凸起抠出来（凸起在该边的边界值上表现为一次突变进入 + 一次反向突变离开）
// 3、参数里每个非空的"把手区域"附近都应该有一个把手：在区域附近找凸起，
// 凸起宽高与区域外接矩形宽高相近（HANDLE_SIZE_MIN_RATIO ~ HANDLE_SIZE_MAX_RATIO）才算匹配
// 4、凸起本身不算 NG，只有"某个把手区域附近找不到匹配的凸起"才算把手缺失（NG 由 CheckRun 上报）
int ImgCheckAnalysisy::CheckHandleByBigMask(const cv::Mat &bigmask)
{
m_bHandleDetSucc = false;
m_bHandleFound = false;
m_bHandleExpect = false;
m_HandleProtrusionList.clear();
m_HandleCandList.clear();
m_HandleRegionResultList.clear();
m_HandleBodyQuad.clear();
if (bigmask.empty())
{
@ -2946,40 +2805,9 @@ int ImgCheckAnalysisy::CheckHandleByBigMask(const cv::Mat &bigmask)
return 1;
}
// 1、从 bigmask 分离凸起区域
// 最小深度 = 系数 × 量化步长：mask 由模型输出 resize 回原图，直边带量化台阶毛刺(台阶高≈模型 1 像素=量化步长)；
// 系数优先取参数配置(JSON handle_param 下的 handle_min_depth/handle_min_area/handle_edge_margin)，
// 未配置时用文件顶部宏的默认值；
// 凸起区域算大了/过于灵敏 → 首选调大 handle_edge_margin(把边缘线整体外推、变相减小凸起区域，
// 不影响深度门槛)；也可调大 handle_min_depth(深度门槛+容差带一起变大)；浅把手漏检 → 反向调小；
// 拿不到模型尺寸时传 0，由 GetMaskProtrusions 按掩膜尺寸自动取值
float fMinDepthCoef = HANDLE_MIN_DEPTH_STEP_COEF;
float fMinAreaCoef = HANDLE_MIN_AREA_COEF;
float fEdgeMarginCoef = HANDLE_EDGE_MARGIN_STEP_COEF;
if (m_pbaseCheckFunction != NULL)
{
const Function_Support_Det &supportDetCfg = m_pbaseCheckFunction->supportDet;
if (supportDetCfg.handle_min_depth_coef > 0) fMinDepthCoef = supportDetCfg.handle_min_depth_coef;
if (supportDetCfg.handle_min_area_coef > 0) fMinAreaCoef = supportDetCfg.handle_min_area_coef;
if (supportDetCfg.handle_edge_margin_coef >= 0) fEdgeMarginCoef = supportDetCfg.handle_edge_margin_coef; // 0=按“最小深度一半”自动
}
int nMinDepth = 0;
int nMinArea = 0;
int nEdgeMargin = 0;
if (AI_Factory && AI_Factory->Align_Outer && AI_Factory->Align_Outer->input_0.width > 0 && AI_Factory->Align_Outer->input_0.height > 0)
{
int nStepX = (int)std::ceil(bigmask.cols * 1.0 / AI_Factory->Align_Outer->input_0.width);
int nStepY = (int)std::ceil(bigmask.rows * 1.0 / AI_Factory->Align_Outer->input_0.height);
int nStep = std::max(1, std::max(nStepX, nStepY));
nMinDepth = (int)(fMinDepthCoef * nStep + 0.5f);
nMinArea = (int)(fMinAreaCoef * nMinDepth * nMinDepth + 0.5f);
if (fEdgeMarginCoef > 0)
{
nEdgeMargin = (int)(fEdgeMarginCoef * nStep + 0.5f);
}
}
// m_HandleBodyQuad：拟合出的主体四边形(左上/右上/右下/左下)；-s 存图观察用，支架偏移检测复用其四边做抗凸起测距/绘制
int re = CheckUtil::GetMaskProtrusions(bigmask, m_HandleProtrusionList, nMinDepth, nMinArea, &m_HandleBodyQuad, nEdgeMargin);
// 1、抠出 bigmask 四周凸起的矩形块
std::vector<Mask_Protrusion_> protrusionList;
int re = CheckUtil::GetMaskProtrusions(bigmask, protrusionList);
if (re != 0)
{
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Handle", "GetMaskProtrusions error %d", re);
@ -3001,27 +2829,33 @@ int ImgCheckAnalysisy::CheckHandleByBigMask(const cv::Mat &bigmask)
}
m_bHandleExpect = (bDetHandle && !regionBoxList.empty());
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Handle", "protrusion num %ld handle region num %ld bDetHandle %s expect %s",
m_HandleProtrusionList.size(), regionBoxList.size(), BOOL_TO_STR(bDetHandle), BOOL_TO_STR(m_bHandleExpect));
// 3、凸起区域实测特征（就近角/面积/深度/填充率，用于日志排查）
for (size_t i = 0; i < m_HandleProtrusionList.size(); i++)
{
const Mask_Protrusion_ &protr = m_HandleProtrusionList[i];
protrusionList.size(), regionBoxList.size(), BOOL_TO_STR(bDetHandle), BOOL_TO_STR(m_bHandleExpect));
// 3、凸起候选实测特征（面积/填充率，仅用于日志排查）
for (size_t i = 0; i < protrusionList.size(); i++)
{
Handle_Candidate_ cand;
cand.protr = protrusionList[i];
// 左/右凸起：沿边为 y 方向，深度为 x 方向；上/下凸起相反
bool bHorz = (cand.protr.nSide == 0 || cand.protr.nSide == 1);
cand.nLen = bHorz ? cand.protr.roi.height : cand.protr.roi.width;
cand.nDepth = bHorz ? cand.protr.roi.width : cand.protr.roi.height;
m_HandleCandList.push_back(cand);
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Handle",
"protrusion %ld corner %d roi [%d %d %d %d] len %.0f depth %.0f area %0.0f fill %0.2f",
i, protr.nCorner, protr.roi.x, protr.roi.y, protr.roi.width, protr.roi.height,
protr.fLen, protr.fDepth, protr.fArea, protr.fFillRatio);
"protrusion %ld side %d roi [%d %d %d %d] len %d depth %d area %0.0f fill %0.2f",
i, cand.protr.nSide, cand.protr.roi.x, cand.protr.roi.y, cand.protr.roi.width, cand.protr.roi.height,
cand.nLen, cand.nDepth, cand.protr.fArea, cand.protr.fFillRatio);
}
// 4、逐个把手区域：在区域附近找宽高匹配的凸起（同一个凸起只匹配给一个区域）
std::vector<bool> usedList(m_HandleProtrusionList.size(), false);
std::vector<bool> usedList(m_HandleCandList.size(), false);
int nFound = 0;
for (size_t ir = 0; ir < regionBoxList.size(); ir++)
{
Handle_Region_Result_ result;
result.nIdx = (int)ir + 1;
result.boxRegion = regionBoxList[ir];
int nMatchIdx = MatchHandleRegion(m_HandleProtrusionList, usedList, result.boxRegion, result.roiHandle);
int nMatchIdx = MatchHandleRegion(m_HandleCandList, usedList, result.boxRegion, result.roiHandle);
result.bFound = (nMatchIdx >= 0);
if (result.bFound)
{
@ -3045,9 +2879,7 @@ int ImgCheckAnalysisy::CheckHandleByBigMask(const cv::Mat &bigmask)
m_pdetlog->AddCheckstr(PrintLevel_0, DET_LOG_LEVEL_3, "Handle", "handle region num %ld found num %d -> %s",
regionBoxList.size(), nFound, m_bHandleFound ? "handle ok" : "handle missing !!");
// 5、存过程图(-s 时)：用于从图像观察把手提取/匹配情况；
// 绿色四边形=拟合出的主体四条边缘；红框=分离出的凸起区域(带编号/就近角/深度)；
// 蓝框=参数把手区域；绿框=匹配到的把手
// 5、存过程图：凸起红框、把手区域蓝框、匹配上的把手绿框（仅调试时）
if (DetImgInfo_shareP->bsaveProcessImg)
{
cv::Mat show;
@ -3059,25 +2891,9 @@ int ImgCheckAnalysisy::CheckHandleByBigMask(const cv::Mat &bigmask)
{
show = bigmask.clone();
}
// 主体四边形(拟合出的四条边缘)
if (m_HandleBodyQuad.size() == 4)
{
std::vector<cv::Point> vecQuad;
for (size_t i = 0; i < m_HandleBodyQuad.size(); i++)
{
vecQuad.push_back(cv::Point(cvRound(m_HandleBodyQuad[i].x), cvRound(m_HandleBodyQuad[i].y)));
}
cv::polylines(show, vecQuad, true, cv::Scalar(0, 255, 0), 8);
}
// 凸起区域：红框 + 编号/就近角/深度
char strTxt[128];
for (size_t i = 0; i < m_HandleProtrusionList.size(); i++)
for (size_t i = 0; i < m_HandleCandList.size(); i++)
{
const Mask_Protrusion_ &protr = m_HandleProtrusionList[i];
cv::rectangle(show, protr.roi, cv::Scalar(0, 0, 255), 8);
snprintf(strTxt, sizeof(strTxt), "#%d C%d d%.0f", (int)i, protr.nCorner, protr.fDepth);
cv::putText(show, strTxt, cv::Point(protr.roi.x, std::max(30, protr.roi.y - 8)),
cv::FONT_HERSHEY_SIMPLEX, 2.0, cv::Scalar(0, 255, 255), 4);
cv::rectangle(show, m_HandleCandList[i].protr.roi, cv::Scalar(0, 0, 255), 8);
}
for (size_t i = 0; i < m_HandleRegionResultList.size(); i++)
{
@ -3193,15 +3009,6 @@ int ImgCheckAnalysisy::CheckTagByBigMask(const cv::Mat &img, const cv::Mat &bigm
return 0;
}
if (m_pbaseCheckFunction->saveImg.bSaveBQDetImg)
{
std::string cur_time_s = CheckUtil::getCurTimeHMS();
std::string strSaveDir = "/home/aidlux/BOE/AI_Detect/" + DetImgInfo_shareP->strImgProductID + "/";
CheckUtil::CreateDir(strSaveDir);
std::string strSavePath_out = strSaveDir + cur_time_s + "_" + DetImgInfo_shareP->strCameraName + "_BQ_out.png";
CheckUtil::SaveImgAsync(strSavePath_out, mask);
}
// 调试存图(仅 -s 时保存)
if (DetImgInfo_shareP && DetImgInfo_shareP->bsaveProcessImg)
{
@ -3240,12 +3047,10 @@ int ImgCheckAnalysisy::CheckTagByBigMask(const cv::Mat &img, const cv::Mat &bigm
}
// 在某个把手区域附近找宽高匹配的凸起
// 匹配条件：1、凸起中心落在把手区域附近（区域宽/高各外扩 fNearRatio 倍）
// 2、凸起宽高与该区域外接矩形宽高的比值都在 [fSizeMin, fSizeMax]（允许横竖互换）
// 范围参数优先取参数配置(JSON handle_param 下的 handle_search_ratio/handle_size_min/handle_size_max)，
// 未配置时用文件顶部宏的默认值
// 匹配条件：1、凸起中心落在把手区域附近（区域宽/高各外扩 HANDLE_NEAR_EXPAND_RATIO）
// 2、凸起宽高与该区域外接矩形宽高的比值都在 [HANDLE_SIZE_MIN_RATIO, HANDLE_SIZE_MAX_RATIO]（允许横竖互换）
// 返回凸起在 candList 中的下标，-1 表示没找到
int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Mask_Protrusion_> &candList, const std::vector<bool> &usedList,
int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Handle_Candidate_> &candList, const std::vector<bool> &usedList,
const cv::Rect &boxRegion, cv::Rect &roiHandle)
{
if (boxRegion.width <= 0 || boxRegion.height <= 0)
@ -3253,21 +3058,9 @@ int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Mask_Protrusion_> &ca
return -1;
}
// 匹配范围参数：JSON 配置优先，未配置时用默认值
float fNearRatio = HANDLE_NEAR_EXPAND_RATIO;
float fSizeMin = HANDLE_SIZE_MIN_RATIO;
float fSizeMax = HANDLE_SIZE_MAX_RATIO;
if (m_pbaseCheckFunction != NULL)
{
const Function_Support_Det &supportDetCfg = m_pbaseCheckFunction->supportDet;
if (supportDetCfg.handle_search_ratio > 0) fNearRatio = supportDetCfg.handle_search_ratio;
if (supportDetCfg.handle_size_min_ratio > 0) fSizeMin = supportDetCfg.handle_size_min_ratio;
if (supportDetCfg.handle_size_max_ratio > 0) fSizeMax = supportDetCfg.handle_size_max_ratio;
}
// 搜索范围：把手区域外扩（宽/高各外扩搜索倍数倍），容忍产品摆放偏差
int nx = std::max(10, (int)(boxRegion.width * fNearRatio));
int ny = std::max(10, (int)(boxRegion.height * fNearRatio));
// 搜索范围：把手区域外扩（宽/高各外扩区域尺寸的一半），容忍产品摆放偏差
int nx = std::max(10, (int)(boxRegion.width * HANDLE_NEAR_EXPAND_RATIO));
int ny = std::max(10, (int)(boxRegion.height * HANDLE_NEAR_EXPAND_RATIO));
cv::Rect searchBox(boxRegion.x - nx, boxRegion.y - ny, boxRegion.width + 2 * nx, boxRegion.height + 2 * ny);
cv::Point pRegionCenter(boxRegion.x + boxRegion.width / 2, boxRegion.y + boxRegion.height / 2);
@ -3281,8 +3074,8 @@ int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Mask_Protrusion_> &ca
{
continue;
}
const Mask_Protrusion_ &cand = candList[i];
const cv::Rect &roi = cand.roi;
const Handle_Candidate_ &cand = candList[i];
const cv::Rect &roi = cand.protr.roi;
if (roi.width <= 0 || roi.height <= 0)
{
continue;
@ -3304,12 +3097,12 @@ int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Mask_Protrusion_> &ca
// 宽高：与把手区域外接矩形的宽高相近（允许横竖互换）
float fw = (float)roi.width;
float fh = (float)roi.height;
bool bSizeOK = (fw >= boxRegion.width * fSizeMin && fw <= boxRegion.width * fSizeMax &&
fh >= boxRegion.height * fSizeMin && fh <= boxRegion.height * fSizeMax);
bool bSizeOK = (fw >= boxRegion.width * HANDLE_SIZE_MIN_RATIO && fw <= boxRegion.width * HANDLE_SIZE_MAX_RATIO &&
fh >= boxRegion.height * HANDLE_SIZE_MIN_RATIO && fh <= boxRegion.height * HANDLE_SIZE_MAX_RATIO);
if (!bSizeOK)
{
bSizeOK = (fw >= boxRegion.height * fSizeMin && fw <= boxRegion.height * fSizeMax &&
fh >= boxRegion.width * fSizeMin && fh <= boxRegion.width * fSizeMax);
bSizeOK = (fw >= boxRegion.height * HANDLE_SIZE_MIN_RATIO && fw <= boxRegion.height * HANDLE_SIZE_MAX_RATIO &&
fh >= boxRegion.width * HANDLE_SIZE_MIN_RATIO && fh <= boxRegion.width * HANDLE_SIZE_MAX_RATIO);
}
if (!bSizeOK)
{
@ -3326,17 +3119,17 @@ int ImgCheckAnalysisy::MatchHandleRegion(const std::vector<Mask_Protrusion_> &ca
if (nBestIdx < 0 && nNearIdx >= 0)
{
// 没匹配上时打印区域内最近的凸起，便于排查阈值
const cv::Rect &roi = candList[nNearIdx].roi;
const cv::Rect &roi = candList[nNearIdx].protr.roi;
m_pdetlog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Handle",
"region box [%d %d %d %d] no match, nearest protrusion corner %d roi [%d %d %d %d] w/h ratio %0.2f %0.2f",
"region box [%d %d %d %d] no match, nearest protrusion roi [%d %d %d %d] w/h ratio %0.2f %0.2f",
boxRegion.x, boxRegion.y, boxRegion.width, boxRegion.height,
candList[nNearIdx].nCorner, roi.x, roi.y, roi.width, roi.height,
roi.x, roi.y, roi.width, roi.height,
(float)roi.width / (float)boxRegion.width, (float)roi.height / (float)boxRegion.height);
}
if (nBestIdx >= 0)
{
roiHandle = candList[nBestIdx].roi;
roiHandle = candList[nBestIdx].protr.roi;
}
return nBestIdx;
}

49
ConfigModule/include/CheckConfigDefine.h
Unescape View File

@ -923,7 +923,6 @@ struct Function_Support_Det
{
// 支架参数（Support_Detect）
bool bDetSupport; // 支架偏位检测开关（Support_Detect.isOpen）
bool bDrawSupport; // 支架绘制开关（Support_Detect.form.support_param.bDrawSupport）：是否绘制支架中心十字/距离线
float x_standard; // 水平方向标准距离（left/right 用）
float y_standard; // 垂直方向标准距离（up/down 用）
std::vector<std::string> edge_select; // 参与计算的方向：up/down/left/right
@ -936,14 +935,6 @@ struct Function_Support_Det
std::vector<std::vector<cv::Point>> handleRegions;
std::vector<cv::Rect> handleBoxes;
float handle_diff; // 把手差异阈值
// 把手提取/匹配范围参数：JSON(Handle_Detect.form.handle_param)下同名键可选配置，未配置用 ImgCheckAnalysisy.cpp
// 顶部宏的默认值；各参数含义/调整影响见该文件参数注释。现场调这些参数不用改代码重编译
float handle_size_min_ratio; // handle_size_min：凸起宽高 / 区域宽高 比值下限；<=0=未配置(默认 0.8)
float handle_size_max_ratio; // handle_size_max：比值上限；<=0=未配置(默认 1.2)
float handle_search_ratio; // handle_search_ratio：区域附近搜索范围外扩倍数；<=0=未配置(默认 5)
float handle_min_depth_coef; // handle_min_depth：凸起最小深度系数(×量化步长)；<=0=未配置(默认 2)
float handle_min_area_coef; // handle_min_area：凸起最小面积系数(×最小深度²)；<=0=未配置(默认 2)
float handle_edge_margin_coef; // handle_edge_margin：边缘线外扩系数(×量化步长)；<0=未配置(默认 3)，0=按“最小深度一半”自动
// 标签参数（BQ_Detect）
bool bDetTag; // 标签检测开关（BQ_Detect.isOpen）
float BQ_area; // 标签检测参数：面积
@ -959,7 +950,6 @@ struct Function_Support_Det
void Init()
{
bDetSupport = false;
bDrawSupport = false;
x_standard = 0;
y_standard = 0;
edge_select.clear();
@ -970,13 +960,6 @@ struct Function_Support_Det
handleRegions.clear();
handleBoxes.clear();
handle_diff = 20;
// 范围参数默认“未配置”：0=未配置(用代码默认)，edge_margin 用 -1 表示未配置(0=自动)
handle_size_min_ratio = 0;
handle_size_max_ratio = 0;
handle_search_ratio = 0;
handle_min_depth_coef = 0;
handle_min_area_coef = 0;
handle_edge_margin_coef = -1;
bDetTag = false;
BQ_area = 0;
BQ_energy = 0;
@ -986,7 +969,6 @@ struct Function_Support_Det
void copy(Function_Support_Det tem)
{
this->bDetSupport = tem.bDetSupport;
this->bDrawSupport = tem.bDrawSupport;
this->x_standard = tem.x_standard;
this->y_standard = tem.y_standard;
this->edge_select.assign(tem.edge_select.begin(), tem.edge_select.end());
@ -997,12 +979,6 @@ struct Function_Support_Det
this->handleRegions.assign(tem.handleRegions.begin(), tem.handleRegions.end());
this->handleBoxes.assign(tem.handleBoxes.begin(), tem.handleBoxes.end());
this->handle_diff = tem.handle_diff;
this->handle_size_min_ratio = tem.handle_size_min_ratio;
this->handle_size_max_ratio = tem.handle_size_max_ratio;
this->handle_search_ratio = tem.handle_search_ratio;
this->handle_min_depth_coef = tem.handle_min_depth_coef;
this->handle_min_area_coef = tem.handle_min_area_coef;
this->handle_edge_margin_coef = tem.handle_edge_margin_coef;
this->bDetTag = tem.bDetTag;
this->BQ_area = tem.BQ_area;
this->BQ_energy = tem.BQ_energy;
@ -1011,18 +987,14 @@ struct Function_Support_Det
}
void print(std::string str)
{
printf("%s>>bDetSupport %d bDrawSupport %d bDetHandle %d bDetTag %d x_standard %f y_standard %f x_offset %f y_offset %f r_offset %f edge num %ld handleRegion num %ld handle_diff %f handleRange[size %.2f~%.2f search %.1f depth %.1f area %.1f margin %.1f(0=自动,<0=默认)] BQ[area %f energy %f len %f hj %f]\n",
str.c_str(), bDetSupport, bDrawSupport, bDetHandle, bDetTag, x_standard, y_standard, x_offset, y_offset, r_offset, edge_select.size(), handleRegions.size(), handle_diff,
handle_size_min_ratio, handle_size_max_ratio, handle_search_ratio, handle_min_depth_coef, handle_min_area_coef, handle_edge_margin_coef,
BQ_area, BQ_energy, BQ_len, BQ_hj);
printf("%s>>bDetSupport %d bDetHandle %d bDetTag %d x_standard %f y_standard %f x_offset %f y_offset %f r_offset %f edge num %ld handleRegion num %ld handle_diff %f BQ[area %f energy %f len %f hj %f]\n",
str.c_str(), bDetSupport, bDetHandle, bDetTag, x_standard, y_standard, x_offset, y_offset, r_offset, edge_select.size(), handleRegions.size(), handle_diff, BQ_area, BQ_energy, BQ_len, BQ_hj);
}
std::string GetInfo(std::string str)
{
char buffer[1024];
sprintf(buffer, "%s>>bDetSupport %d bDrawSupport %d bDetHandle %d bDetTag %d x_standard %f y_standard %f x_offset %f y_offset %f r_offset %f edge num %ld handleRegion num %ld handle_diff %f handleRange[size %.2f~%.2f search %.1f depth %.1f area %.1f margin %.1f(0=自动,<0=默认)] BQ[area %f energy %f len %f hj %f]\n",
str.c_str(), bDetSupport, bDrawSupport, bDetHandle, bDetTag, x_standard, y_standard, x_offset, y_offset, r_offset, edge_select.size(), handleRegions.size(), handle_diff,
handle_size_min_ratio, handle_size_max_ratio, handle_search_ratio, handle_min_depth_coef, handle_min_area_coef, handle_edge_margin_coef,
BQ_area, BQ_energy, BQ_len, BQ_hj);
char buffer[512];
sprintf(buffer, "%s>>bDetSupport %d bDetHandle %d bDetTag %d x_standard %f y_standard %f x_offset %f y_offset %f r_offset %f edge num %ld handleRegion num %ld handle_diff %f BQ[area %f energy %f len %f hj %f]\n",
str.c_str(), bDetSupport, bDetHandle, bDetTag, x_standard, y_standard, x_offset, y_offset, r_offset, edge_select.size(), handleRegions.size(), handle_diff, BQ_area, BQ_energy, BQ_len, BQ_hj);
std::string str123 = buffer;
return str123;
}
@ -1180,7 +1152,6 @@ struct Base_Function_SaveImg
bool bSaveAIDetImg; // mark 存图
bool bSaveClsImg; // 分类 存图
bool bSaveAlginImg; // 定位 存图
bool bSaveBQDetImg; // 标签 存图
Base_Function_SaveImg()
{
@ -1192,7 +1163,6 @@ struct Base_Function_SaveImg
bSaveAIDetImg = false;
bSaveClsImg = false;
bSaveAlginImg = false;
bSaveBQDetImg = false;
}
void copy(Base_Function_SaveImg tem)
@ -1202,18 +1172,17 @@ struct Base_Function_SaveImg
this->bSaveAIDetImg = tem.bSaveAIDetImg;
this->bSaveClsImg = tem.bSaveClsImg;
this->bSaveAlginImg = tem.bSaveAlginImg;
this->bSaveBQDetImg = tem.bSaveBQDetImg;
}
void print(std::string str)
{
printf("%s>>bOpen %d bSaveAIDetImg %d bSaveClsImg %d bSaveAlginImg %d bSaveBQDetImg %d\n", str.c_str(),
bOpen, bSaveAIDetImg, bSaveClsImg, bSaveAlginImg, bSaveBQDetImg);
printf("%s>>bOpen %d bSaveAIDetImg %d bSaveClsImg %d bSaveAlginImg %d \n", str.c_str(),
bOpen, bSaveAIDetImg, bSaveClsImg, bSaveAlginImg);
}
std::string GetInfo(std::string str)
{
char buffer[256];
sprintf(buffer, "%s>>bOpen %d bSaveAIDetImg %d bSaveClsImg %d bSaveAlginImg %d bSaveBQDetImg %d\n", str.c_str(),
bOpen, bSaveAIDetImg, bSaveClsImg, bSaveAlginImg, bSaveBQDetImg);
sprintf(buffer, "%s>>bOpen %d bSaveAIDetImg %d bSaveClsImg %d bSaveAlginImg %d \n", str.c_str(),
bOpen, bSaveAIDetImg, bSaveClsImg, bSaveAlginImg);
std::string str123 = buffer;
return str123;
}

41
ConfigModule/src/JsonConfig.cpp
Unescape View File

@ -873,10 +873,6 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{
_config.saveImg.bSaveAIDetImg = value_f["form"]["SaveImg_Config"]["AI_Det_Save"].asBool();
}
if (value_f["form"]["SaveImg_Config"]["BQ_Det_Save"])
{
_config.saveImg.bSaveBQDetImg = value_f["form"]["SaveImg_Config"]["BQ_Det_Save"].asBool();
}
}
else
{
@ -925,12 +921,6 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{
auto value_param = value_f["form"]["support_param"];
// 支架绘制开关：控制结果图上是否绘制支架中心十字/距离线（默认关，兼容旧参数）
if (value_param["bDrawSupport"].isBool())
{
_config.supportDet.bDrawSupport = value_param["bDrawSupport"].asBool();
}
if (value_param["x_standard"])
{
_config.supportDet.x_standard = value_param["x_standard"].asFloat();
@ -977,37 +967,6 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{
_config.supportDet.handle_diff = handle_p["handle_diff"].asFloat();
}
// 把手提取/匹配范围参数（均可选：未配置时用 ImgCheckAnalysisy.cpp 顶部宏的默认值）
// handle_size_min/max ：凸起宽高与把手区域外接矩形宽高的比值允许区间（默认 0.8 ~ 1.2）
// handle_search_ratio ：把手区域附近搜索范围外扩倍数（默认 5）
// handle_min_depth ：凸起最小深度系数(× 定位模型量化步长)（默认 2）
// handle_min_area ：凸起最小面积系数(× 最小深度²)（默认 2）
// handle_edge_margin ：主体边缘线外扩系数(× 量化步长)，0=按“最小深度一半”自动（默认 3）
// 含义/调整影响详见 ImgCheckAnalysisy.cpp 顶部参数注释
if (handle_p["handle_size_min"])
{
_config.supportDet.handle_size_min_ratio = handle_p["handle_size_min"].asFloat();
}
if (handle_p["handle_size_max"])
{
_config.supportDet.handle_size_max_ratio = handle_p["handle_size_max"].asFloat();
}
if (handle_p["handle_search_ratio"])
{
_config.supportDet.handle_search_ratio = handle_p["handle_search_ratio"].asFloat();
}
if (handle_p["handle_min_depth"])
{
_config.supportDet.handle_min_depth_coef = handle_p["handle_min_depth"].asFloat();
}
if (handle_p["handle_min_area"])
{
_config.supportDet.handle_min_area_coef = handle_p["handle_min_area"].asFloat();
}
if (handle_p["handle_edge_margin"])
{
_config.supportDet.handle_edge_margin_coef = handle_p["handle_edge_margin"].asFloat();
}
bool bNewFormat = handle_p["handle_region1"].isArray();
for (int idx = 0; idx < HANDLE_REGION_MAX_NUM; idx++)
{

204
example/deal.cpp
Unescape View File

@ -5,7 +5,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include <algorithm>
#include "CheckUtil.hpp"
std::string ExtractFileNameWithoutExtension(const std::string &strImgPath)
{
@ -102,7 +101,6 @@ deal::deal()
m_nCurUseCPUIDX = 0;
m_nSaveDetprocessImg = 0;
m_nPushImgCount = 0;
m_nResultRecvCount = 0;
m_DetResult.Init();
for (int i = 0; i < READ_IMG_THREAD_NUM; i++)
{
@ -816,8 +814,6 @@ void deal::ResultThread(int id)
{
strlog += "/result";
}
// 确保日志目录存在(否则 writeLog 报 Failed to open file)
_sysmkdirs_1(strlog.substr(0, strlog.find_last_of('/')));
writeLog(strlog, m_DetResult.strlist);
mutex_DetResult_.unlock();
@ -865,7 +861,6 @@ void deal::GetDealResultToQueu()
{
mutex_Result_list.lock();
m_Result_list.push(checkResult);
m_nResultRecvCount++;
mutex_Result_list.unlock();
}
else
@ -908,30 +903,6 @@ bool deal::ReadSystemConfig(const std::string &strPath)
}
int deal::GetDetImageInfo(std::string strProductID, std::string strSearchImg, std::vector<JC_IMAGE_INFO_> &jcImageInfoList)
{
// -f 批量跑新格式: 产品目录下 input 子目录, 只取 _src 原图
// (如 1M10121544R3B2_t_face_bright_src.jpg, 从图片名解析产品ID和相机名)
if (fs::is_directory(strSearchImg + "/input"))
{
jcImageInfoList.erase(jcImageInfoList.begin(), jcImageInfoList.end());
std::vector<cv::String> srcImgPaths;
cv::glob(strSearchImg + "/input/*.jpg", srcImgPaths, false);
for (int idx = 0; idx < srcImgPaths.size(); idx++)
{
JC_IMAGE_INFO_ tem;
int re = GetImgInfo_BACKPLATE_SRC(srcImgPaths.at(idx), &tem);
if (re != 0)
{
continue;
}
if (tem.strProductID == "")
{
tem.strProductID = strProductID;
}
jcImageInfoList.push_back(tem);
}
return 0;
}
// 1、获取图片路径
std::vector<cv::String> img_paths;
std::string strs1 = strSearchImg + "/*.jpg";
@ -1029,63 +1000,6 @@ int deal::GetImgInfo_POL_ET_PNG(std::string strImgPath, JC_IMAGE_INFO_ *pImageIn
}
return 0;
}
// -f 批量跑新格式: 解析图片名组装产品信息
// 图片名示例: 1M10121544R3B2_t_face_bright_src.jpg
// 产品ID: 第一个 '_' 之前的部分 (1M10121544R3B2)
// 相机名: 直接匹配文件名中的相机名(t_face_bright / t_face_dark), 只处理后缀为 _src 的原图
// 通道名: 统一用 t_face
int deal::GetImgInfo_BACKPLATE_SRC(std::string strImgPath, JC_IMAGE_INFO_ *pImageInfo)
{
if (pImageInfo == NULL)
{
return 1;
}
std::string strName = ExtractFileNameWithoutExtension(strImgPath);
// 只处理后缀为 _src 的原图, 跳过 _roi 等其它图
const std::string strSrcSuffix = "_src";
if (strName.size() <= strSrcSuffix.size() ||
strName.compare(strName.size() - strSrcSuffix.size(), strSrcSuffix.size(), strSrcSuffix) != 0)
{
return 1;
}
// 直接匹配文件名中的相机名(t_face_bright / t_face_dark)
std::string strCamName = "";
if (strName.find("t_face_bright") != std::string::npos)
{
strCamName = "t_face_bright";
}
else if (strName.find("t_face_dark") != std::string::npos)
{
strCamName = "t_face_dark";
}
if (strCamName == "")
{
printf("GetImgInfo_BACKPLATE_SRC: no camera match, skip %s\n", strImgPath.c_str());
return 1;
}
// 产品ID = 文件名第一个 '_' 之前的部分
std::string strProductID = strName;
size_t nPos = strName.find('_');
if (nPos != std::string::npos)
{
strProductID = strName.substr(0, nPos);
}
pImageInfo->strProductID = strProductID;
pImageInfo->strCamID = strCamName;
pImageInfo->strchannelName = "t_face"; // 通道名统一用 t_face
pImageInfo->strName = strName;
pImageInfo->strPath = strImgPath;
printf("strImgPath %s strName %s strProductID %s strCam %s strChannel %s\n",
strImgPath.c_str(), strName.c_str(), strProductID.c_str(), strCamName.c_str(), pImageInfo->strchannelName.c_str());
return 0;
}
int deal::InsertDetResult(ReadImgInfo tem)
{
std::lock_guard<std::mutex> lock(mtx_List[Mutex_Type_DetResult]);
@ -1289,36 +1203,6 @@ int deal::DetImg()
// getchar();
m_nSystemCheckType = CHECK_TYPE_OFFLING;
StartThread(THREAD_RUN_ALL);
// -8 循环执行:保持常驻,重复处理同一批产品
if (runConfig.bLoop)
{
while (true)
{
usleep(1000 * 1000);
}
}
// -f 批量(不加 -8 只执行一次):等待全部产品处理完成后退出
// DealImg 线程处理完一批后会清空 m_product_ID_List 并等待结果队列清空
while (true)
{
usleep(200 * 1000);
size_t nResultSize = 0;
{
std::lock_guard<std::mutex> lock(mutex_Result_list);
nResultSize = m_Result_list.size();
}
if (m_product_ID_List.empty() && nResultSize <= 0)
{
break;
}
}
// 留时间给结果线程把最后一组结果写完
usleep(2 * 1000 * 1000);
printf(">>> -f batch complete, exit \n");
fflush(NULL);
_exit(0);
return 0;
}
int deal::ReJson_product(std::vector<Json_Det_Path> &jsonList, std::string strProductName)
@ -1668,55 +1552,6 @@ int deal::LoadProductID(std::string strImgPath)
m_product_ID_List.erase(m_product_ID_List.begin(), m_product_ID_List.end());
std::vector<cv::String> img_paths;
// -f 批量跑新格式适配(参考 data/img/test-2 结构):
// <filePath>/<产品ID>_<时间戳>/input/<产品ID>_<相机名>_<位置>_src.jpg
// 也支持直接传入单个产品目录或产品目录下的 input 目录
{
std::string strPath = strImgPath;
while (!strPath.empty() && strPath[strPath.size() - 1] == '/')
{
strPath.erase(strPath.size() - 1);
}
fs::path rootPath(strPath);
if (!strPath.empty() && fs::is_directory(rootPath))
{
// 兼容直接传入 input 目录: 使用其上一级产品目录
if (rootPath.filename() == "input" && rootPath.has_parent_path())
{
rootPath = rootPath.parent_path();
}
std::vector<std::string> productDirList;
if (fs::is_directory(rootPath / "input"))
{
// 直接传入单个产品目录
productDirList.push_back(rootPath.string());
}
else
{
// 批量根目录: 含 input 子目录的子目录视为一个产品
for (const auto &entry : fs::directory_iterator(rootPath))
{
if (entry.is_directory() && fs::is_directory(entry.path() / "input"))
{
productDirList.push_back(entry.path().string());
}
}
}
if (!productDirList.empty())
{
std::sort(productDirList.begin(), productDirList.end());
for (const auto &strProductDir : productDirList)
{
m_product_ID_List.push_back(strProductDir);
std::cout << "new format product dir: " << strProductDir << std::endl;
}
return 0;
}
}
}
// tif 格式
{
std::string str_bmp = strImgPath + "/*.jpg";
@ -1765,11 +1600,6 @@ int deal::LoadProductID(std::string strImgPath)
}
}
if (m_product_ID_List.empty())
{
printf("warning: no product dir/image found under %s\n", strImgPath.c_str());
}
return 0;
}
int deal::DelImg_Cell_ET()
@ -1820,13 +1650,6 @@ int deal::Det_OneProduct_Cell_ET(std::string strProductName, int Idx)
{
std::string strProductID = GetFileName(strProductName);
// -f 批量跑新格式: 产品目录名为 <产品ID>_<时间戳>(如 1M10121544R3B2_20261012.151444.066219)
// 取第一个 '_' 之前的部分作为产品ID; 旧格式目录名本身即产品ID(无 '_')不受影响
size_t nProductIDPos = strProductID.find('_');
if (nProductIDPos != std::string::npos)
{
strProductID = strProductID.substr(0, nProductIDPos);
}
// 获取图片路径
std::vector<JC_IMAGE_INFO_> detImgInfoList;
@ -1916,33 +1739,6 @@ int deal::Det_OneProduct_Cell_ET(std::string strProductName, int Idx)
}
}
// -f 批量逐个产品处理:等待本产品的检测结果全部返回后,再处理下一个产品,
// 避免多个产品同时积压在检测队列中(内存/检测器压力过大导致卡死)
if (AllImgNum > 0)
{
int nWaitCnt = 0;
while (true)
{
int nRecv = 0;
int nPush = 0;
{
std::lock_guard<std::mutex> lock(mutex_Result_list);
nRecv = m_nResultRecvCount;
nPush = m_nPushImgCount;
}
if (nRecv >= nPush)
{
break;
}
if (nWaitCnt % 250 == 0)
{
printf(">>> waiting %s check result %d/%d ...\n", strProductID.c_str(), nRecv, nPush);
}
nWaitCnt++;
usleep(20 * 1000);
}
}
m_DetResult.one_result_list.push_back(tem_one);
m_DetResult.det_num_all++;
// if (m_DetResult.det_num_all == 1)

4
example/deal.h
Unescape View File

@ -551,9 +551,6 @@ private:
int GetImgInfo_POL_ET_PNG(std::string strImgPath, JC_IMAGE_INFO_ *pImageInfo);
// -f 批量跑新格式: 解析 <产品ID>_<相机名>_<位置>_src.jpg 图片名组装产品信息(相机名 t_face_bright/t_face_dark, 通道名统一 t_face)
int GetImgInfo_BACKPLATE_SRC(std::string strImgPath, JC_IMAGE_INFO_ *pImageInfo);
// 功能测试
int Det_Funtion_Test();
// 边缘测试
@ -652,7 +649,6 @@ public:
int m_nSaveDetprocessImg;
int m_nPushImgCount; // 送检图片总数（拆分后）
int m_nResultRecvCount; // 已收到检测结果总数(-f 逐个产品处理:等当前产品结果返回后再跑下一个)
cv::Rect m_CutRoi;
Det_File_Result_Info m_DetResult;

2
example/test_example.cpp
Unescape View File

@ -85,8 +85,6 @@ 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_BACKPLATE -8: 循环执行程序(常驻)，不加 -8 只执行一次" << endl;
cout << "*** 8、./test_BACKPLATE -f filepath: 批量执行 filepath 下的套图(新格式: <产品ID>_<时间戳>/input/<产品ID>_<相机名>_xxx_src.jpg, 相机名 t_face_bright/t_face_dark, 通道名统一 t_face)" << endl;
cout << "******************************************************" << endl;
return 0;

Write Preview
Loading…
Cancel
Save