|
|
#include "TcsCheck.h"
|
|
|
#include "CheckUtil.hpp" // 异步存图：CheckUtil::SaveImgAsync / WaitSaveImgDone
|
|
|
|
|
|
class CLock
|
|
|
{
|
|
|
public:
|
|
|
CLock(pthread_mutex_t * attr) : m_attr(attr) {
|
|
|
pthread_mutex_lock(m_attr);
|
|
|
};
|
|
|
~CLock() {
|
|
|
pthread_mutex_unlock(m_attr);
|
|
|
|
|
|
};
|
|
|
protected:
|
|
|
pthread_mutex_t * m_attr;
|
|
|
};
|
|
|
|
|
|
CTcsCheck::CTcsCheck()
|
|
|
: m_nInitStart(0)
|
|
|
, m_bSystemExit(0)
|
|
|
, m_nInitEnd(0)
|
|
|
{
|
|
|
m_cpCfg.nAreaLowFilter = 80;
|
|
|
m_cpCfg.nBlockSize = 100;
|
|
|
m_cpCfg.nDiscardTop = 170;
|
|
|
m_cpCfg.nDiscardBottom = 170;
|
|
|
m_cpCfg.nDiscardLeft = 180;
|
|
|
m_cpCfg.nDiscardRight = 460;
|
|
|
|
|
|
m_cpCfg.fZoomRatio = 0.25;
|
|
|
m_cpCfg.nFilterLow = 15;
|
|
|
m_cpCfg.nFilterHigh = 15;
|
|
|
m_cpCfg.nAreaFilter = 10;
|
|
|
m_cpCfg.nCountFilter = 50;
|
|
|
}
|
|
|
CTcsCheck::~CTcsCheck()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
void CTcsCheck::SetCheckDir(std::string dirIn,std::string dirOut)
|
|
|
{
|
|
|
m_strDirIn = dirIn;
|
|
|
m_strDirOut = dirOut;
|
|
|
}
|
|
|
void CTcsCheck::SetChecConfig(CHECK_PARAM* cp)
|
|
|
{
|
|
|
// CHECK_PARAM 内含 std::string，不能用 memcpy：memcpy 会把源对象 string 内部的
|
|
|
// _M_data 指针一并拷过来，于是拷贝出的 string 认为自己持有堆内存，
|
|
|
// 析构时会 free 到源对象的栈缓冲（短串）或重复释放（长串），随机崩溃。
|
|
|
// 整体赋值（拷贝构造/赋值）才是正确做法。
|
|
|
if (cp == nullptr) return;
|
|
|
m_cpCfg = *cp;
|
|
|
}
|
|
|
std::string CTcsCheck::GetFileName(const std::string& path) const
|
|
|
{
|
|
|
std::size_t pos = path.find_last_of("/\\");
|
|
|
std::string name = (pos == std::string::npos) ? path : path.substr(pos + 1);
|
|
|
std::size_t dot = name.find_last_of('.');
|
|
|
if (dot == std::string::npos) {
|
|
|
return name;
|
|
|
}
|
|
|
return name.substr(0, dot);
|
|
|
}
|
|
|
|
|
|
// 递归创建多级目录
|
|
|
bool CTcsCheck::CreateDirectories(std::string path, mode_t mode )
|
|
|
{
|
|
|
std::string fullPath = path;
|
|
|
size_t pos = 0;
|
|
|
|
|
|
while ((pos = fullPath.find_first_of("/", pos + 1)) != std::string::npos) {
|
|
|
std::string subPath = fullPath.substr(0, pos);
|
|
|
if (subPath.empty()) continue;
|
|
|
|
|
|
if (mkdir(subPath.c_str(), mode) != 0 && errno != EEXIST) {
|
|
|
std::cerr << "创建子目录失败: " << subPath << " - " << strerror(errno) << std::endl;
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 创建最后一级目录
|
|
|
if (mkdir(path.c_str(), mode) != 0 && errno != EEXIST) {
|
|
|
std::cerr << "创建最终目录失败: " << path << " - " << strerror(errno) << std::endl;
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
std::cout << "多级目录创建成功: " << path << std::endl;
|
|
|
return true;
|
|
|
}
|
|
|
void CTcsCheck::LoadImages()
|
|
|
{
|
|
|
if (access(m_strDirIn.c_str(),F_OK) == 0)
|
|
|
{
|
|
|
cv::glob(m_strDirIn, m_fileList);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
std::cout << "Dir " << m_strDirIn << " is NOT existed!" << std::endl;
|
|
|
}
|
|
|
std::cout << "Create OUT directory : " << m_strDirOut << std::endl;
|
|
|
CreateDirectories(m_strDirOut);
|
|
|
|
|
|
}
|
|
|
// 在给定二值图上取「最大连通域的外接框」（输入需为 CV_8UC1）
|
|
|
static cv::Rect LargestComponentRect(const cv::Mat &matBinary)
|
|
|
{
|
|
|
if (matBinary.empty()) return cv::Rect(0, 0, 0, 0);
|
|
|
|
|
|
cv::Mat labels;
|
|
|
cv::Mat stats;
|
|
|
cv::Mat centroids;
|
|
|
const int nLabels = cv::connectedComponentsWithStats(matBinary, labels, stats, centroids, 8, CV_32S);
|
|
|
if (nLabels <= 1) {
|
|
|
return cv::Rect(0,0,0,0);
|
|
|
}
|
|
|
|
|
|
int maxArea = 0;
|
|
|
int maxLabel = -1;
|
|
|
for (int label = 1; label < nLabels; ++label) {
|
|
|
const int area = stats.at<int>(label, cv::CC_STAT_AREA);
|
|
|
if (area > maxArea) {
|
|
|
maxArea = area;
|
|
|
maxLabel = label;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (maxLabel < 0) {
|
|
|
return cv::Rect(0,0,0,0);
|
|
|
}
|
|
|
|
|
|
const int x = stats.at<int>(maxLabel, cv::CC_STAT_LEFT);
|
|
|
const int y = stats.at<int>(maxLabel, cv::CC_STAT_TOP);
|
|
|
const int w = stats.at<int>(maxLabel, cv::CC_STAT_WIDTH);
|
|
|
const int h = stats.at<int>(maxLabel, cv::CC_STAT_HEIGHT);
|
|
|
return cv::Rect(x, y, w, h);
|
|
|
}
|
|
|
|
|
|
// 产品定位用的「最大连通域外接框」。
|
|
|
//
|
|
|
// connectedComponentsWithStats 的输出 labels 是 CV_32S —— 4 字节/像素：
|
|
|
// 22754x60000 的整幅图 → labels 单次就要 5.5 GB，实测该分支进程峰值 9.3 GB；
|
|
|
// 4 个相机并发时这是最容易把机器内存打爆的地方（整机 OOM 时最后失败的分配
|
|
|
// 往往落在 TensorRT 内嵌的 LLVM JIT 上，日志表现为 “LLVM ERROR: out of memory”）。
|
|
|
//
|
|
|
// 因此先在 1/ds 缩略图上定位最大连通域，再在原图对应局部窗口（外扩 2*ds）上精修：
|
|
|
// 最大块在缩略图上的外接框与原图外接框最多相差 ds 像素，外扩后窗口必然完整包含它，
|
|
|
// 所以精修结果与「直接对全图做 CC」一致，而 labels 内存降到 1/ds² 量级。
|
|
|
cv::Rect CTcsCheck::GetBoundingRect(cv::Mat matBinary)
|
|
|
{
|
|
|
if (matBinary.empty() || matBinary.type() != CV_8UC1)
|
|
|
{
|
|
|
return cv::Rect(0, 0, 0, 0);
|
|
|
}
|
|
|
|
|
|
const int ds = 8; // 缩略图倍数
|
|
|
const long long kCoarseMinPixels = 4LL * 1024 * 1024; // 小于 4M 像素直接走原逻辑
|
|
|
const long long imgPixels = static_cast<long long>(matBinary.cols) * matBinary.rows;
|
|
|
|
|
|
if (imgPixels <= kCoarseMinPixels)
|
|
|
{
|
|
|
return LargestComponentRect(matBinary);
|
|
|
}
|
|
|
|
|
|
// 1) 粗定位：INTER_AREA 后 >0 即视为该单元内有残点
|
|
|
cv::Mat small;
|
|
|
cv::resize(matBinary, small,
|
|
|
cv::Size(std::max(1, matBinary.cols / ds), std::max(1, matBinary.rows / ds)), 0, 0, cv::INTER_AREA);
|
|
|
cv::Mat smallBin;
|
|
|
cv::threshold(small, smallBin, 0, 255, cv::THRESH_BINARY);
|
|
|
|
|
|
const cv::Rect smallRect = LargestComponentRect(smallBin);
|
|
|
if (smallRect.width <= 0 || smallRect.height <= 0)
|
|
|
{
|
|
|
return cv::Rect(0, 0, 0, 0);
|
|
|
}
|
|
|
|
|
|
// 2) 缩略图坐标 → 原图坐标，外扩 2*ds 覆盖降采样带来的边界误差
|
|
|
const int pad = 2 * ds;
|
|
|
cv::Rect coarse(smallRect.x * ds - pad, smallRect.y * ds - pad,
|
|
|
(smallRect.width + 2) * ds + 2 * pad, (smallRect.height + 2) * ds + 2 * pad);
|
|
|
coarse = coarse & cv::Rect(0, 0, matBinary.cols, matBinary.rows);
|
|
|
|
|
|
// 粗定位明显不可信（外接框面积不足全图 0.1%）时退回全图 CC，保证行为不变
|
|
|
const long long coarseArea = static_cast<long long>(smallRect.width) * smallRect.height * ds * ds;
|
|
|
if (coarse.width <= 0 || coarse.height <= 0 || coarseArea * 1000 < imgPixels)
|
|
|
{
|
|
|
return LargestComponentRect(matBinary);
|
|
|
}
|
|
|
|
|
|
// 3) 在原图局部窗口内精修，得到像素级精确的外接框
|
|
|
const cv::Rect local = LargestComponentRect(matBinary(coarse));
|
|
|
if (local.width <= 0 || local.height <= 0)
|
|
|
{
|
|
|
return LargestComponentRect(matBinary);
|
|
|
}
|
|
|
return cv::Rect(coarse.x + local.x, coarse.y + local.y, local.width, local.height);
|
|
|
}
|
|
|
cv::Rect CTcsCheck::GetCropArea(cv::Rect rtValid)
|
|
|
{
|
|
|
// 在原图坐标系中对 ROI 四边分别内收对应的 discard 宽度。
|
|
|
// 若尺寸不足以同时内收，则保持原 ROI（不做"部分边"裁剪）。
|
|
|
|
|
|
const int outW = rtValid.width - m_cpCfg.nDiscardLeft - m_cpCfg.nDiscardRight;
|
|
|
const int outH = rtValid.height - m_cpCfg.nDiscardTop - m_cpCfg.nDiscardBottom;
|
|
|
if (outW <= 0 || outH <= 0) {
|
|
|
return rtValid;
|
|
|
}
|
|
|
|
|
|
cv::Rect innerRect(rtValid.x + m_cpCfg.nDiscardLeft, rtValid.y + m_cpCfg.nDiscardTop, outW, outH);
|
|
|
const cv::Rect imageRect(0, 0, m_sizeImage.width, m_sizeImage.height);
|
|
|
innerRect = innerRect & imageRect;
|
|
|
if (innerRect.width <= 0 || innerRect.height <= 0) {
|
|
|
return rtValid;
|
|
|
}
|
|
|
return innerRect;
|
|
|
}
|
|
|
// ============================================================
|
|
|
// EstimateBackgroundMap — 局部背景基准图（抗大缺陷污染）
|
|
|
//
|
|
|
// 旧实现用「块内灰度均值」当阈值中心，缺陷一旦覆盖块内较大面积，
|
|
|
// 均值就会被缺陷灰度带偏：
|
|
|
// · 均值落在「背景峰」与「缺陷峰」之间的空隙 → 容忍带内一个像素都没有
|
|
|
// → 反相后整块变白（大面积误检，缺陷其实没占满块）；
|
|
|
// · 均值贴近缺陷灰度 → 缺陷被判成背景、背景反被判成缺陷（极性翻转）。
|
|
|
//
|
|
|
// 这里改用「中值」估计背景：中值一定是窗口内真实存在的灰度值，
|
|
|
// 只要缺陷不占到窗口一半以上就不会被带偏。窗口取 3 倍块边长（覆盖 3×3 个块），
|
|
|
// 因此单块甚至相邻几块内的大缺陷都污染不了该块的背景基准。
|
|
|
//
|
|
|
// 为控制耗时，先在 1/ds 缩略图上做中值（等效窗口 = ds × 粗粒度核），
|
|
|
// 再插值放大回原尺寸 —— 背景本身是低频的，放大误差可忽略。
|
|
|
// 实测 1500×3750：全分辨率大核中值 ~146ms，降采样后 ~10ms。
|
|
|
// ============================================================
|
|
|
cv::Mat CTcsCheck::EstimateBackgroundMap(const cv::Mat& matGray, int blockSize)
|
|
|
{
|
|
|
cv::Mat gray8;
|
|
|
if (matGray.type() == CV_8UC1) {
|
|
|
gray8 = matGray;
|
|
|
} else {
|
|
|
matGray.convertTo(gray8, CV_8UC1);
|
|
|
}
|
|
|
if (gray8.empty()) return cv::Mat();
|
|
|
|
|
|
const int bgWinScale = 3; // 背景估计窗口 = 3 倍块边长
|
|
|
const int kMaxSafe = 201; // medianBlur 大核上限（本机 OpenCV 4.5 实测 >301 断言失败）
|
|
|
|
|
|
// 降采样倍数：保证粗粒度核不超过 kMaxSafe
|
|
|
int ds = 4;
|
|
|
while (bgWinScale * blockSize / ds > kMaxSafe) ds *= 2;
|
|
|
|
|
|
// 缩略图：INTER_AREA 即块内均值，缺陷只会让个别单元变成离群点，中值可剔除
|
|
|
cv::Mat small;
|
|
|
cv::resize(gray8, small,
|
|
|
cv::Size(std::max(1, gray8.cols / ds), std::max(1, gray8.rows / ds)), 0, 0, cv::INTER_AREA);
|
|
|
|
|
|
int k = bgWinScale * std::max(1, blockSize / ds);
|
|
|
if (k % 2 == 0) ++k;
|
|
|
if (k < 3) k = 3; // 允许 k 大于缩略图尺寸，medianBlur 会按边界复制处理
|
|
|
|
|
|
cv::Mat smallBg;
|
|
|
cv::medianBlur(small, smallBg, k);
|
|
|
|
|
|
cv::Mat matBg;
|
|
|
cv::resize(smallBg, matBg, gray8.size(), 0, 0, cv::INTER_LINEAR);
|
|
|
return matBg;
|
|
|
}
|
|
|
|
|
|
cv::Mat CTcsCheck::AdaptiveBinary(cv::Mat matBlur)
|
|
|
{
|
|
|
// 按 nBlockSize 分块，用每个块的局部背景基准做动态阈值。
|
|
|
// 规则：落在 [ref-low, ref+high] 内置 0，超出置 255。
|
|
|
// 注意 ref 取「大窗口中值背景」而非块内均值，避免大缺陷把阈值中心带偏导致整块变白。
|
|
|
if (matBlur.empty()) return cv::Mat();
|
|
|
cv::Mat result = cv::Mat::zeros(matBlur.size(), CV_8UC1);
|
|
|
|
|
|
// 块边长不超过图像尺寸；同步回 m_cpCfg，保证 ClassifyBlobs 的块网格一致
|
|
|
const int blockSize = std::max(1, std::min(m_cpCfg.nBlockSize, std::min(matBlur.cols, matBlur.rows)));
|
|
|
m_cpCfg.nBlockSize = blockSize;
|
|
|
|
|
|
// 局部背景基准图（大窗口中值）
|
|
|
const cv::Mat matBg = EstimateBackgroundMap(matBlur, blockSize);
|
|
|
|
|
|
for (int y = 0; y < matBlur.rows; y += blockSize) {
|
|
|
for (int x = 0; x < matBlur.cols; x += blockSize) {
|
|
|
// 末列/末行窗口贴边对齐（与相邻窗口重叠），不产生残缺块
|
|
|
const int bx = std::min(x, std::max(0, matBlur.cols - blockSize));
|
|
|
const int by = std::min(y, std::max(0, matBlur.rows - blockSize));
|
|
|
const cv::Rect blockRect(bx, by, blockSize, blockSize);
|
|
|
cv::Mat block = matBlur(blockRect);
|
|
|
|
|
|
// 背景基准：取该块范围内背景图的均值（抹平中值图的量化台阶）
|
|
|
const double avg = matBg.empty() ? cv::mean(block)[0] : cv::mean(matBg(blockRect))[0];
|
|
|
const double minGrey = std::max(0.0, avg - m_cpCfg.nFilterLow);
|
|
|
const double maxGrey = std::min(255.0, avg + m_cpCfg.nFilterHigh);
|
|
|
|
|
|
cv::Mat blockBin;
|
|
|
cv::inRange(block, minGrey, maxGrey, blockBin);
|
|
|
cv::bitwise_not(blockBin, blockBin);
|
|
|
blockBin.copyTo(result(blockRect));
|
|
|
|
|
|
// 传统检测残点图存图
|
|
|
if (m_cpCfg.bDebugsaveImg)
|
|
|
{
|
|
|
std::string roi_ext = "[" + std::to_string(bx) + "," + std::to_string(by) + "]";
|
|
|
std::string strSaveDir = "/home/aidlux/BOE/CELL_AOI/AI_Detect/" + m_cpCfg.productId + "/";
|
|
|
std::string strSavePath_in = strSaveDir + m_cpCfg.productChannel +"_"+ roi_ext + "_"+ "in" + ".png";
|
|
|
std::string strSavePath_out = strSaveDir + m_cpCfg.productChannel +"_"+ roi_ext + "_"+ "out" + ".png";
|
|
|
// 父目录由异步存图器按需创建
|
|
|
CheckUtil::SaveImgAsync(strSavePath_in, block);
|
|
|
CheckUtil::SaveImgAsync(strSavePath_out, blockBin);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
// ============================================================
|
|
|
// ClassifyBlobs — 纯分类函数
|
|
|
// 对残点二值图做连通域分析 + 缺陷分类，结果写入 m_vecDefectInfo
|
|
|
// ============================================================
|
|
|
void CTcsCheck::ClassifyBlobs(const cv::Mat& blurCrop, const cv::Mat& imgBlob)
|
|
|
{
|
|
|
m_vecDefectInfo.clear();
|
|
|
|
|
|
// 分步计时：记录每个步骤的耗时（ms）
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
auto tPrev = tStart;
|
|
|
auto logStep = [&](const std::string& step) {
|
|
|
auto tNow = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tNow - tPrev).count();
|
|
|
std::cout << "[ClassifyBlobs] " << step << " 耗时(ms): " << elapsedMs << std::endl;
|
|
|
tPrev = tNow;
|
|
|
};
|
|
|
|
|
|
cv::Mat labels;
|
|
|
cv::Mat stats;
|
|
|
cv::Mat centroids;
|
|
|
const int nLabels = cv::connectedComponentsWithStats(imgBlob, labels, stats, centroids, 8, CV_32S);
|
|
|
// logStep("1.连通域分析");
|
|
|
if (nLabels <= 1) return;
|
|
|
|
|
|
// 大块缺陷的面积阈值（分类决策用，非过滤）
|
|
|
const int largeAreaThreshold = std::max(1, m_cpCfg.nBlockSize * m_cpCfg.nBlockSize / 4);
|
|
|
|
|
|
// 面积/个数过滤已统一上移到 BLobToDetResult 处理，
|
|
|
// 此处对所有连通域逐一分类，仅做缺陷类型打标签。
|
|
|
for (int label = 1; label < nLabels; ++label) {
|
|
|
const int area = stats.at<int>(label, cv::CC_STAT_AREA);
|
|
|
if (area < 5) continue;
|
|
|
// bounding rect
|
|
|
const int x = stats.at<int>(label, cv::CC_STAT_LEFT);
|
|
|
const int y = stats.at<int>(label, cv::CC_STAT_TOP);
|
|
|
const int w = stats.at<int>(label, cv::CC_STAT_WIDTH);
|
|
|
const int h = stats.at<int>(label, cv::CC_STAT_HEIGHT);
|
|
|
|
|
|
// blob 区域均值：仅在 bounding rect 局部计算，避免全图 mask
|
|
|
cv::Mat blobMask = (labels(cv::Rect(x, y, w, h)) == label);
|
|
|
double blobMean = cv::mean(blurCrop(cv::Rect(x, y, w, h)), blobMask)[0];
|
|
|
|
|
|
// 所属局部块均值
|
|
|
const double cx = centroids.at<double>(label, 0);
|
|
|
const double cy = centroids.at<double>(label, 1);
|
|
|
int blockX = std::max(0, std::min(static_cast<int>(cx) / m_cpCfg.nBlockSize, (blurCrop.cols - 1) / m_cpCfg.nBlockSize));
|
|
|
int blockY = std::max(0, std::min(static_cast<int>(cy) / m_cpCfg.nBlockSize, (blurCrop.rows - 1) / m_cpCfg.nBlockSize));
|
|
|
|
|
|
const int roiX = blockX * m_cpCfg.nBlockSize;
|
|
|
const int roiY = blockY * m_cpCfg.nBlockSize;
|
|
|
const int roiW = std::min(m_cpCfg.nBlockSize, blurCrop.cols - roiX);
|
|
|
const int roiH = std::min(m_cpCfg.nBlockSize, blurCrop.rows - roiY);
|
|
|
const double localMean = cv::mean(blurCrop(cv::Rect(roiX, roiY, roiW, roiH)))[0];
|
|
|
const double greyDiff = blobMean - localMean;
|
|
|
|
|
|
// ============================================================
|
|
|
// 缺陷分类决策树
|
|
|
// 长宽比 >= 3 → SCRATCH (划伤)
|
|
|
// 紧凑 + 面积小 → POINT (硬质颗粒)
|
|
|
// 紧凑 + 大面积+暗 → DIRTY (脏污)
|
|
|
// 紧凑 + 大面积+亮 → FADING (淡斑)
|
|
|
// ============================================================
|
|
|
float aspectRatio = static_cast<float>(std::max(w, h)) / std::max(1, std::min(w, h));
|
|
|
int defectType = DEFECT_TYPE_OK;
|
|
|
|
|
|
if (aspectRatio >= 3.0f) {
|
|
|
defectType = DEFECT_TYPE_SCRATCH;
|
|
|
} else if (area < largeAreaThreshold) {
|
|
|
defectType = DEFECT_TYPE_POINT;
|
|
|
} else if (greyDiff < 0) {
|
|
|
defectType = DEFECT_TYPE_DIRTY;
|
|
|
} else {
|
|
|
defectType = DEFECT_TYPE_FADING_SPOTS;
|
|
|
}
|
|
|
|
|
|
DEFECT_INFO info;
|
|
|
info.nDefectType = defectType;
|
|
|
info.nDefectArea = area;
|
|
|
info.nDefectX = x;
|
|
|
info.nDefectY = y;
|
|
|
info.nDefectWidth = w;
|
|
|
info.nDefectHeight = h;
|
|
|
info.dGreyDiff = greyDiff;
|
|
|
info.strDefectCode = DEFECT_TYPE_CODE[defectType];
|
|
|
info.strDefectDesc = DEFECT_TYPE_DESC[defectType];
|
|
|
m_vecDefectInfo.push_back(info);
|
|
|
}
|
|
|
// logStep("4.缺陷分类决策");
|
|
|
|
|
|
// // 总耗时
|
|
|
// {
|
|
|
// auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
// double totalMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
// std::cout << "[ClassifyBlobs] 总耗时(ms): " << totalMs << std::endl;
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
|
// DrawBlobInfoImage — 纯绘制函数
|
|
|
// 基于 m_vecDefectInfo 在 crop 图上绘制缺陷标注
|
|
|
// ============================================================
|
|
|
cv::Mat CTcsCheck::DrawBlobInfoImage(const cv::Mat& imgCrop, const cv::Mat& imgBlob)
|
|
|
{
|
|
|
cv::Mat cropColor;
|
|
|
cv::cvtColor(imgCrop, cropColor, cv::COLOR_GRAY2BGR);
|
|
|
|
|
|
for (const auto& info : m_vecDefectInfo) {
|
|
|
const cv::Rect blobRect(info.nDefectX, info.nDefectY, info.nDefectWidth, info.nDefectHeight);
|
|
|
|
|
|
// 根据缺陷类型使用不同颜色绘制
|
|
|
cv::Scalar drawColor;
|
|
|
switch (info.nDefectType) {
|
|
|
case DEFECT_TYPE_POINT: drawColor = cv::Scalar(0, 255, 0); break; // 绿色
|
|
|
case DEFECT_TYPE_SCRATCH: drawColor = cv::Scalar(0, 0, 255); break; // 红色
|
|
|
case DEFECT_TYPE_DIRTY: drawColor = cv::Scalar(255, 0, 0); break; // 蓝色
|
|
|
case DEFECT_TYPE_FADING_SPOTS: drawColor = cv::Scalar(255, 255, 0); break; // 青色
|
|
|
default: drawColor = cv::Scalar(0, 255, 0); break;
|
|
|
}
|
|
|
|
|
|
// 在 blob 区域内找轮廓
|
|
|
cv::Mat roiBlob = imgBlob(blobRect & cv::Rect(0, 0, imgBlob.cols, imgBlob.rows));
|
|
|
std::vector<std::vector<cv::Point>> contours;
|
|
|
cv::findContours(roiBlob.clone(), contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
|
|
|
// 偏移轮廓坐标到原图位置
|
|
|
for (auto& cnt : contours) {
|
|
|
for (auto& pt : cnt) {
|
|
|
pt.x += info.nDefectX;
|
|
|
pt.y += info.nDefectY;
|
|
|
}
|
|
|
}
|
|
|
cv::drawContours(cropColor, contours, -1, drawColor, 2);
|
|
|
cv::rectangle(cropColor, blobRect, cv::Scalar(0, 0, 255), 1);
|
|
|
|
|
|
// 文本标注
|
|
|
std::ostringstream oss;
|
|
|
oss << info.strDefectCode << " A:" << info.nDefectArea
|
|
|
<< " dG:" << std::fixed << std::setprecision(1) << info.dGreyDiff;
|
|
|
int textX = std::max(0, info.nDefectX);
|
|
|
int textY = std::max(15, info.nDefectY - 3);
|
|
|
cv::putText(cropColor, oss.str(), cv::Point(textX, textY),
|
|
|
cv::FONT_HERSHEY_SIMPLEX, 0.45, drawColor, 1);
|
|
|
}
|
|
|
|
|
|
return cropColor;
|
|
|
}
|
|
|
// ============================================================
|
|
|
// 独立检测接口
|
|
|
// 对单张图做：阈值定位→裁剪→缩放→高斯模糊→自适应二值化
|
|
|
// 输出残点二值图 blobImg，内部缓存 m_matBlur 供后续分类
|
|
|
// 返回: 0=成功, -1=无产品或输入异常
|
|
|
// ============================================================
|
|
|
int CTcsCheck::TraditionalDetect(const cv::Mat& img, cv::Rect detRoi, cv::Mat& blobImg)
|
|
|
{
|
|
|
if (img.empty())
|
|
|
{
|
|
|
blobImg = cv::Mat();
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 分步计时：记录每个步骤的耗时（ms）
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
auto tPrev = tStart;
|
|
|
auto logStep = [&](const std::string& step) {
|
|
|
auto tNow = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tNow - tPrev).count();
|
|
|
std::cout << "[TraditionalDetect] " << step << " 耗时(ms): " << elapsedMs << std::endl;
|
|
|
tPrev = tNow;
|
|
|
};
|
|
|
|
|
|
// getchar();
|
|
|
// cv::Mat showImg = img.clone();
|
|
|
// cv::rectangle(showImg, detRoi, cv::Scalar(255), 2);
|
|
|
// cv::imwrite("detRoi.png", showImg);
|
|
|
m_matLoad = img;
|
|
|
// 确保 m_sizeImage 始终与 m_matLoad 同步
|
|
|
m_sizeImage = img.size();
|
|
|
|
|
|
// 先把上一张图的中间结果清掉：任何提前 return 都不允许下游（TraditionalClassify）
|
|
|
// 误用旧图的 mask / ROI（坐标会整体错位，且会多攥住一份 GB 级缓冲）
|
|
|
m_matBlur.release();
|
|
|
m_matBlob.release();
|
|
|
m_rtCrop = cv::Rect(0, 0, 0, 0);
|
|
|
m_vecDefectInfo.clear();
|
|
|
|
|
|
cv::Rect rtCrop = detRoi;
|
|
|
if(detRoi.size() == img.size())
|
|
|
{
|
|
|
// 1. 全局阈值 → 产品区域定位
|
|
|
cv::Mat matBinary;
|
|
|
cv::threshold(m_matLoad, matBinary, m_cpCfg.nAreaLowFilter, 255, cv::THRESH_BINARY);
|
|
|
// logStep("1.全局阈值");
|
|
|
|
|
|
// 2. 获取最大连通域外接矩形
|
|
|
cv::Rect rtValid = GetBoundingRect(matBinary);
|
|
|
if (rtValid == cv::Rect(0, 0, 0, 0))
|
|
|
{
|
|
|
m_matLoad.release(); // 不再需要引用 detImg
|
|
|
blobImg = cv::Mat();
|
|
|
return -1;
|
|
|
}
|
|
|
// logStep("2.最大连通域外接矩形");
|
|
|
|
|
|
// 3. 裁剪边缘
|
|
|
rtCrop = GetCropArea(rtValid);
|
|
|
// logStep("3.裁剪边缘");
|
|
|
}
|
|
|
|
|
|
// 安全裁剪: 确保 rtCrop 不超出 m_matLoad 边界
|
|
|
{
|
|
|
const cv::Rect imgRect(0, 0, m_matLoad.cols, m_matLoad.rows);
|
|
|
rtCrop = rtCrop & imgRect;
|
|
|
if (rtCrop.width <= 0 || rtCrop.height <= 0)
|
|
|
{
|
|
|
m_matLoad.release(); // 不再需要引用 detImg
|
|
|
blobImg = cv::Mat();
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
// 缓存裁剪区域，供 TraditionalClassify 将小图坐标映射回原图
|
|
|
m_rtCrop = rtCrop;
|
|
|
// logStep("4.安全裁剪");
|
|
|
|
|
|
cv::Mat matCrop = m_matLoad(rtCrop);
|
|
|
// logStep("5.ROI裁剪");
|
|
|
|
|
|
// 6. 缩放
|
|
|
const int outW = std::max(1, static_cast<int>(matCrop.cols * m_cpCfg.fZoomRatio));
|
|
|
const int outH = std::max(1, static_cast<int>(matCrop.rows * m_cpCfg.fZoomRatio));
|
|
|
cv::Mat matResized;
|
|
|
cv::resize(matCrop, matResized, cv::Size(outW, outH), 0, 0, cv::INTER_AREA);
|
|
|
// logStep("6.缩放");
|
|
|
|
|
|
// 7. 高斯模糊 — 缓存到 m_matBlur
|
|
|
cv::GaussianBlur(matResized, m_matBlur, cv::Size(5, 5), 0);
|
|
|
// cv::imwrite("matResized.png", matResized);
|
|
|
// cv::imwrite("m_matBlur.png", m_matBlur);
|
|
|
// logStep("7.高斯模糊");
|
|
|
|
|
|
// 8. 自适应二值化检测
|
|
|
m_matBlob = AdaptiveBinary(m_matBlur);
|
|
|
blobImg = m_matBlob;
|
|
|
// logStep("8.自适应二值化");
|
|
|
|
|
|
// 9. 反向映射：只生成下游需要的全尺寸残点 mask（resultMaskImg / Blob 计算）。
|
|
|
// 下游 GetALLBlob / BLobToDetResult 都以 detImg 为坐标基准，所以 mask 必须与 detImg 等大，
|
|
|
// 且 ROI 之外必须是 0。
|
|
|
// 写法上不再用 cv::Mat::zeros(全图)（那会先给整幅图做一次 memset，22754x60000 时约 1.3 GB），
|
|
|
// 而是创建一个不初始化的缓冲，只把 ROI 之外的条带清零 —— 结果完全等价，省一次全图 memset。
|
|
|
if (m_cpCfg.fZoomRatio > 0)
|
|
|
{
|
|
|
cv::Mat fullMask;
|
|
|
fullMask.create(m_matLoad.size(), CV_8UC1); // create 不做初始化
|
|
|
|
|
|
const int y0 = rtCrop.y;
|
|
|
const int y1 = rtCrop.y + rtCrop.height;
|
|
|
const int x0 = rtCrop.x;
|
|
|
const int x1 = rtCrop.x + rtCrop.width;
|
|
|
if (y0 > 0) fullMask.rowRange(0, y0).setTo(0);
|
|
|
if (y1 < fullMask.rows) fullMask.rowRange(y1, fullMask.rows).setTo(0);
|
|
|
cv::Mat mid = fullMask.rowRange(y0, y1);
|
|
|
if (x0 > 0) mid.colRange(0, x0).setTo(0);
|
|
|
if (x1 < mid.cols) mid.colRange(x1, mid.cols).setTo(0);
|
|
|
|
|
|
cv::resize(m_matBlob, fullMask(rtCrop), cv::Size(rtCrop.width, rtCrop.height), 0, 0, cv::INTER_NEAREST);
|
|
|
blobImg = fullMask;
|
|
|
|
|
|
// logStep("9.反向映射(mask)");
|
|
|
}
|
|
|
|
|
|
// 检测期间只需要引用 detImg，结束即松开：
|
|
|
// 否则 CTcsCheck 会一直攥住整幅检测图（GB 级）不放，上层即使释放 detImg 也回收不掉。
|
|
|
// （分类阶段只用 m_matBlur / m_matBlob 这两张小图）
|
|
|
m_matLoad.release();
|
|
|
|
|
|
// 总耗时
|
|
|
{
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double totalMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
// std::cout << "[TraditionalDetect] 总耗时(ms): " << totalMs << std::endl;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
|
// TraditionalClassify — 独立分类接口
|
|
|
// 优先在小图缓存（m_matBlur/m_matBlob）上做连通域分析+缺陷分类，
|
|
|
// 再将结果坐标映射回原图，避免对全尺寸 mask 做昂贵计算。
|
|
|
// 返回: 分类到的缺陷数量，<0 表示异常
|
|
|
// ============================================================
|
|
|
int CTcsCheck::TraditionalClassify(const cv::Mat& blobImg)
|
|
|
{
|
|
|
// 全尺寸 mask 仅是小图 INTER_NEAREST 放大结果，连通域数量/形状完全等价，
|
|
|
// 在小图上分类可避免对全尺寸图做昂贵的 connectedComponentsWithStats。
|
|
|
if (m_matBlur.empty() || m_matBlob.empty())
|
|
|
{
|
|
|
// 回退路径：旧行为是对全尺寸 mask 直接做连通域分析，
|
|
|
// 而 connectedComponentsWithStats 的 labels 是 CV_32S（4 B/px）：
|
|
|
// 22754x60000 的 mask 单次就要 5.5 GB，是明确的 OOM 风险点。
|
|
|
// 正常流程里 TraditionalDetect 必然已经填好小图缓存，这里只保留小图的兼容路径。
|
|
|
m_vecDefectInfo.clear();
|
|
|
if (m_matLoad.empty() || blobImg.empty()) return -1;
|
|
|
|
|
|
const double pxCount = static_cast<double>(blobImg.cols) * blobImg.rows;
|
|
|
if (pxCount > 16.0 * 1024 * 1024)
|
|
|
{
|
|
|
std::cout << "[TraditionalClassify] no small-image cache, mask "
|
|
|
<< blobImg.cols << "x" << blobImg.rows
|
|
|
<< " -> refuse full-size connectedComponentsWithStats (OOM risk)" << std::endl;
|
|
|
return -1;
|
|
|
}
|
|
|
ClassifyBlobs(m_matLoad, blobImg);
|
|
|
return static_cast<int>(m_vecDefectInfo.size());
|
|
|
}
|
|
|
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
ClassifyBlobs(m_matBlur, m_matBlob);
|
|
|
|
|
|
// 小图坐标/面积映射回原图坐标系，与下游 blobs.blobTab（全尺寸坐标）对齐
|
|
|
const double scaleX = (m_matBlob.cols > 0) ? static_cast<double>(m_rtCrop.width) / m_matBlob.cols : 1.0;
|
|
|
const double scaleY = (m_matBlob.rows > 0) ? static_cast<double>(m_rtCrop.height) / m_matBlob.rows : 1.0;
|
|
|
for (auto& info : m_vecDefectInfo)
|
|
|
{
|
|
|
info.nDefectX = static_cast<int>(info.nDefectX * scaleX + 0.5) + m_rtCrop.x;
|
|
|
info.nDefectY = static_cast<int>(info.nDefectY * scaleY + 0.5) + m_rtCrop.y;
|
|
|
info.nDefectWidth = std::max(1, static_cast<int>(info.nDefectWidth * scaleX + 0.5));
|
|
|
info.nDefectHeight = std::max(1, static_cast<int>(info.nDefectHeight * scaleY + 0.5));
|
|
|
info.nDefectArea = std::max(1, static_cast<int>(info.nDefectArea * scaleX * scaleY + 0.5));
|
|
|
}
|
|
|
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double totalMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
std::cout << "[TraditionalClassify] 总耗时(ms): " << totalMs << std::endl;
|
|
|
|
|
|
return static_cast<int>(m_vecDefectInfo.size());
|
|
|
}
|
|
|
|
|
|
void CTcsCheck::ProcessImages(bool bDrawResult)
|
|
|
{
|
|
|
LoadImages();
|
|
|
|
|
|
std::cout << "TOTAL file count = " << m_fileList.size() << std::endl;
|
|
|
|
|
|
for (int i = 0; i < m_fileList.size(); i ++ )
|
|
|
{
|
|
|
m_matLoad = cv::imread(m_fileList[i],cv::IMREAD_GRAYSCALE);
|
|
|
m_strCurFile = GetFileName(m_fileList[i]);
|
|
|
|
|
|
m_sizeImage = m_matLoad.size();
|
|
|
Process(bDrawResult);
|
|
|
}
|
|
|
|
|
|
// 异步存图收尾：确保队列里的调试图全部落盘后再返回
|
|
|
CheckUtil::WaitSaveImgDone();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void CTcsCheck::DetectWithAdaptiveBinary(bool bDraw )
|
|
|
{
|
|
|
cv::Mat matBinary,matCrop,matResized,matBlur,matDraw;
|
|
|
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
cv::threshold(m_matLoad,matBinary,m_cpCfg.nAreaLowFilter,255,cv::THRESH_BINARY);
|
|
|
|
|
|
// Obtain Key Region Range
|
|
|
cv::Rect rtValid = GetBoundingRect(matBinary);
|
|
|
if (rtValid == cv::Rect(0,0,0,0))
|
|
|
{
|
|
|
std::cout << "NO product" << std::endl;
|
|
|
return ;
|
|
|
}
|
|
|
|
|
|
// crop image
|
|
|
cv::Rect rtCrop = GetCropArea(rtValid);
|
|
|
matCrop = m_matLoad(rtCrop).clone();
|
|
|
|
|
|
// image zoom
|
|
|
const int outW = std::max(1, static_cast<int>(matBinary.cols * m_cpCfg.fZoomRatio));
|
|
|
const int outH = std::max(1, static_cast<int>(matBinary.rows * m_cpCfg.fZoomRatio));
|
|
|
cv::resize(matCrop, matResized, cv::Size(outW, outH), 0, 0, cv::INTER_AREA);
|
|
|
|
|
|
// image blur
|
|
|
cv::GaussianBlur(matResized, matBlur, cv::Size(5, 5), 0);
|
|
|
|
|
|
// 二值化
|
|
|
m_matBlob = AdaptiveBinary(matBlur);
|
|
|
|
|
|
// 分类：对残点二值图做连通域分析+缺陷分类
|
|
|
ClassifyBlobs(matBlur, m_matBlob);
|
|
|
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
|
|
|
std::cout << "耗时(ms): " << elapsedMs << std::endl;
|
|
|
|
|
|
if (bDraw)
|
|
|
{
|
|
|
matDraw = DrawBlobInfoImage(matResized, m_matBlob);
|
|
|
|
|
|
std::string strOutFile,strDebug;
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Binary.png";
|
|
|
cv::imwrite(strOutFile,matBinary);
|
|
|
strOutFile = m_strDirOut + "/" +m_strCurFile + "_Crop.png";
|
|
|
cv::imwrite(strOutFile,matResized);
|
|
|
strOutFile = m_strDirOut + "/" +m_strCurFile + "_Blob.png";
|
|
|
cv::imwrite(strOutFile,m_matBlob);
|
|
|
strOutFile = m_strDirOut + "/" +m_strCurFile + "_Draw.png";
|
|
|
cv::imwrite(strOutFile,matDraw);
|
|
|
}
|
|
|
}
|
|
|
void CTcsCheck::DetectWithDoH(bool bDraw,double dSigma,int nThreshold )
|
|
|
{
|
|
|
cv::Mat matBinary,matCrop,matResized,matBlur,matDraw;
|
|
|
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
cv::threshold(m_matLoad,matBinary,m_cpCfg.nAreaLowFilter,255,cv::THRESH_BINARY);
|
|
|
|
|
|
// Obtain Key Region Range
|
|
|
cv::Rect rtValid = GetBoundingRect(matBinary);
|
|
|
if (rtValid == cv::Rect(0,0,0,0))
|
|
|
{
|
|
|
std::cout << "NO product" << std::endl;
|
|
|
return ;
|
|
|
}
|
|
|
|
|
|
// crop image
|
|
|
cv::Rect rtCrop = GetCropArea(rtValid);
|
|
|
matCrop = m_matLoad(rtCrop).clone();
|
|
|
|
|
|
// image zoom
|
|
|
const int outW = std::max(1, static_cast<int>(matBinary.cols * m_cpCfg.fZoomRatio));
|
|
|
const int outH = std::max(1, static_cast<int>(matBinary.rows * m_cpCfg.fZoomRatio));
|
|
|
cv::resize(matCrop, matResized, cv::Size(outW, outH), 0, 0, cv::INTER_AREA);
|
|
|
|
|
|
cv::Mat matFloat,matDoh,matNorm;
|
|
|
// 转换为浮点型以进行精确的导数计算
|
|
|
matResized.convertTo(matFloat, CV_64F);
|
|
|
|
|
|
// 2. 高斯平滑（可选，用于去噪和定义尺度）
|
|
|
double sigma = dSigma; // 根据斑点大小调整
|
|
|
cv::Mat smoothed;
|
|
|
cv::GaussianBlur(matFloat, matBlur, cv::Size(0, 0), sigma);
|
|
|
|
|
|
// 3. 计算二阶导数 Ixx, Iyy, Ixy
|
|
|
cv::Mat Ixx, Iyy, Ixy;
|
|
|
cv::Sobel(matBlur, Ixx, CV_64F, 2, 0, 3); // 对 x 求二阶导
|
|
|
cv::Sobel(matBlur, Iyy, CV_64F, 0, 2, 3); // 对 y 求二阶导
|
|
|
cv::Sobel(matBlur, Ixy, CV_64F, 1, 1, 3); // 先对 x 求导，再对 y 求导
|
|
|
|
|
|
// 4. 计算 DoH 响应：det(H) = Ixx * Iyy - Ixy^2
|
|
|
cv::multiply(Ixx, Iyy, matDoh);
|
|
|
cv::subtract(matDoh, Ixy.mul(Ixy), matDoh);
|
|
|
|
|
|
// 5. 后处理：寻找局部极大值作为斑点
|
|
|
cv::normalize(matDoh, matNorm, 0, 255, cv::NORM_MINMAX, CV_8U);
|
|
|
|
|
|
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
|
|
|
std::cout << "耗时(ms): " << elapsedMs << std::endl;
|
|
|
// 6. 绘制并显示结果
|
|
|
if ( bDraw)
|
|
|
{
|
|
|
// 寻找局部极大值（简化示例，实际应用需更严谨的邻域比较）
|
|
|
std::vector<cv::KeyPoint> keypoints;
|
|
|
int threshold_value = nThreshold; // 需要根据图像调整的阈值
|
|
|
for (int i = 1; i < matDoh.rows - 1; ++i) {
|
|
|
for (int j = 1; j < matDoh.cols - 1; ++j) {
|
|
|
double val = matDoh.at<double>(i, j);
|
|
|
if (val > threshold_value)
|
|
|
//&& val > matDoh.at<double>(i - 1, j) && val > matDoh.at<double>(i + 1, j) &&
|
|
|
//val > matDoh.at<double>(i, j - 1) && val > matDoh.at<double>(i, j + 1))
|
|
|
{
|
|
|
// 此处可更精确地计算斑点的尺度和响应强度
|
|
|
keypoints.push_back(cv::KeyPoint(j, i, 2 * sigma));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
cv::cvtColor(matNorm, matDraw, cv::COLOR_GRAY2BGR);
|
|
|
cv::drawKeypoints(matDraw, keypoints, matDraw, cv::Scalar(0, 0, 255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
|
|
|
|
|
|
std::string strOutFile;
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Resize.png";
|
|
|
cv::imwrite(strOutFile,matResized);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Norm.png";
|
|
|
cv::imwrite(strOutFile,matNorm);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Draw.png";
|
|
|
cv::imwrite(strOutFile,matDraw);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void CTcsCheck::DetectWithLoG(bool bDraw, double dSigma, int nThreshold)
|
|
|
{
|
|
|
// ===================================================================
|
|
|
// LoG (Laplacian of Gaussian) 斑点检测
|
|
|
// 原理: LoG = trace(H) = Ixx + Iyy，是 Hessian 矩阵的迹
|
|
|
// 相比 DoH (det(H)=Ixx*Iyy-Ixy²)：
|
|
|
// - 速度: 只需1次 Laplacian，DoH 需要3次 Sobel + 乘减运算 (~3x 加速)
|
|
|
// - 精度: LoG 是旋转不变的各向同性斑点检测器，对圆形缺陷响应最优
|
|
|
// ===================================================================
|
|
|
cv::Mat matBinary, matCrop, matResized, matBlur, matDraw;
|
|
|
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// 1. 全局阈值 -> 定位产品区域
|
|
|
cv::threshold(m_matLoad, matBinary, m_cpCfg.nAreaLowFilter, 255, cv::THRESH_BINARY);
|
|
|
|
|
|
// 2. 获取有效区域外接矩形
|
|
|
cv::Rect rtValid = GetBoundingRect(matBinary);
|
|
|
if (rtValid == cv::Rect(0, 0, 0, 0))
|
|
|
{
|
|
|
std::cout << "NO product" << std::endl;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 3. 裁剪边缘
|
|
|
cv::Rect rtCrop = GetCropArea(rtValid);
|
|
|
matCrop = m_matLoad(rtCrop).clone();
|
|
|
|
|
|
// 4. 缩放
|
|
|
const int outW = std::max(1, static_cast<int>(matBinary.cols * m_cpCfg.fZoomRatio));
|
|
|
const int outH = std::max(1, static_cast<int>(matBinary.rows * m_cpCfg.fZoomRatio));
|
|
|
cv::resize(matCrop, matResized, cv::Size(outW, outH), 0, 0, cv::INTER_AREA);
|
|
|
|
|
|
// 5. 转浮点型 + 高斯平滑（尺度选择）
|
|
|
cv::Mat matFloat;
|
|
|
matResized.convertTo(matFloat, CV_64F);
|
|
|
cv::GaussianBlur(matFloat, matBlur, cv::Size(0, 0), dSigma);
|
|
|
|
|
|
// 6. 核心: Laplacian 响应（等价于 Ixx + Iyy）
|
|
|
// 相比 DoH 省去了 Ixy 计算和乘减步骤
|
|
|
cv::Mat matLoG;
|
|
|
cv::Laplacian(matBlur, matLoG, CV_64F, 3);
|
|
|
|
|
|
// 7. 取绝对值（同时检测亮斑和暗斑）
|
|
|
matLoG = cv::abs(matLoG);
|
|
|
|
|
|
// 8. 归一化到 [0,255]
|
|
|
cv::Mat matNorm;
|
|
|
cv::normalize(matLoG, matNorm, 0, 255, cv::NORM_MINMAX, CV_8U);
|
|
|
|
|
|
// 保存斑点图供外部使用
|
|
|
m_matBlob = matNorm.clone();
|
|
|
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
std::cout << "LoG 耗时(ms): " << elapsedMs << std::endl;
|
|
|
|
|
|
// 9. 可视化
|
|
|
if (bDraw)
|
|
|
{
|
|
|
// 非极大值抑制 + 阈值筛选关键点
|
|
|
std::vector<cv::KeyPoint> keypoints;
|
|
|
for (int i = 1; i < matLoG.rows - 1; ++i)
|
|
|
{
|
|
|
for (int j = 1; j < matLoG.cols - 1; ++j)
|
|
|
{
|
|
|
double val = matLoG.at<double>(i, j);
|
|
|
// 局部极大值检测（3×3邻域）
|
|
|
if (val > nThreshold &&
|
|
|
val >= matLoG.at<double>(i - 1, j) &&
|
|
|
val >= matLoG.at<double>(i + 1, j) &&
|
|
|
val >= matLoG.at<double>(i, j - 1) &&
|
|
|
val >= matLoG.at<double>(i, j + 1))
|
|
|
{
|
|
|
keypoints.push_back(cv::KeyPoint(j, i, 2.0f * static_cast<float>(dSigma)));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cv::cvtColor(matNorm, matDraw, cv::COLOR_GRAY2BGR);
|
|
|
cv::drawKeypoints(matDraw, keypoints, matDraw, cv::Scalar(0, 0, 255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
|
|
|
|
|
|
std::string strOutFile;
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Resize.png";
|
|
|
cv::imwrite(strOutFile, matResized);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Norm.png";
|
|
|
cv::imwrite(strOutFile, matNorm);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Draw.png";
|
|
|
cv::imwrite(strOutFile, matDraw);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTcsCheck::DetectWithAdaptiveBinaryOptimized(bool bDraw)
|
|
|
{
|
|
|
// ===================================================================
|
|
|
// DetectWithAdaptiveBinary 优化版
|
|
|
// 与原始版保持相同的 OpenCV SIMD 加速路径, 避免 naive 像素循环
|
|
|
//
|
|
|
// 当下真正有效的优化方向 (非本次实现):
|
|
|
// - cv::UMat: 启用 OpenCL GPU 加速, 代码改动 2 行 (Mat → UMat)
|
|
|
// - 多线程并行: 用 cv::parallel_for_ 处理分块
|
|
|
// - 缩小 nBlockSize 减少块数 (精度/速度 trade-off)
|
|
|
// ===================================================================
|
|
|
cv::Mat matBinary, matCrop, matResized, matBlur, matDraw;
|
|
|
|
|
|
auto tStart = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
cv::threshold(m_matLoad, matBinary, m_cpCfg.nAreaLowFilter, 255, cv::THRESH_BINARY);
|
|
|
|
|
|
// Obtain Key Region Range
|
|
|
cv::Rect rtValid = GetBoundingRect(matBinary);
|
|
|
if (rtValid == cv::Rect(0, 0, 0, 0))
|
|
|
{
|
|
|
std::cout << "NO product" << std::endl;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// crop image
|
|
|
cv::Rect rtCrop = GetCropArea(rtValid);
|
|
|
matCrop = m_matLoad(rtCrop).clone();
|
|
|
|
|
|
// image zoom
|
|
|
const int outW = std::max(1, static_cast<int>(matBinary.cols * m_cpCfg.fZoomRatio));
|
|
|
const int outH = std::max(1, static_cast<int>(matBinary.rows * m_cpCfg.fZoomRatio));
|
|
|
cv::resize(matCrop, matResized, cv::Size(outW, outH), 0, 0, cv::INTER_AREA);
|
|
|
|
|
|
// image blur
|
|
|
cv::GaussianBlur(matResized, matBlur, cv::Size(5, 5), 0);
|
|
|
|
|
|
// 二值化 — 使用原始 AdaptiveBinary (OpenCV SIMD 内部加速)
|
|
|
m_matBlob = AdaptiveBinary(matBlur);
|
|
|
|
|
|
// 分类：对残点二值图做连通域分析+缺陷分类
|
|
|
ClassifyBlobs(matBlur, m_matBlob);
|
|
|
|
|
|
auto tEnd = std::chrono::high_resolution_clock::now();
|
|
|
double elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(tEnd - tStart).count();
|
|
|
|
|
|
std::cout << "AdaptiveBinaryOpt 耗时(ms): " << elapsedMs << std::endl;
|
|
|
|
|
|
if (bDraw)
|
|
|
{
|
|
|
matDraw = DrawBlobInfoImage(matResized, m_matBlob);
|
|
|
|
|
|
std::string strOutFile;
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Binary.png";
|
|
|
cv::imwrite(strOutFile, matBinary);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Crop.png";
|
|
|
cv::imwrite(strOutFile, matResized);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Blob.png";
|
|
|
cv::imwrite(strOutFile, m_matBlob);
|
|
|
strOutFile = m_strDirOut + "/" + m_strCurFile + "_Draw.png";
|
|
|
cv::imwrite(strOutFile, matDraw);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTcsCheck::Process(bool bDraw)
|
|
|
{
|
|
|
//默认使用优化版 AdaptiveBinary：积分图加速 + findNonZero 快速定位
|
|
|
//DetectWithAdaptiveBinaryOptimized(bDraw);
|
|
|
// 备选方法:
|
|
|
DetectWithAdaptiveBinary(bDraw);
|
|
|
// DetectWithLoG(bDraw, 2.0, 48);
|
|
|
// DetectWithDoH(bDraw, 2.0, 48);
|
|
|
} |
