|
|
/*
|
|
|
* @Author: your name
|
|
|
* @Date: 2022-04-20 15:50:00
|
|
|
* @LastEditTime: 2025-09-23 10:29:01
|
|
|
* @LastEditors: xiewenji 527774126@qq.com
|
|
|
* @Description: 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
|
|
|
* @FilePath: /ZCXD_MonitorPlatform/src/CoreLogicModule/src/CamDeal.cpp
|
|
|
*/
|
|
|
#include "CameraCheckAnalysisy.hpp"
|
|
|
#include "ImgCheckAnalysisy.hpp"
|
|
|
#include "CheckUtil.hpp"
|
|
|
#include "Define.h"
|
|
|
#include <atomic>
|
|
|
|
|
|
CameraCheckAnalysisy::CameraCheckAnalysisy()
|
|
|
{
|
|
|
|
|
|
m_nErrorCode = 0; // 错误代码
|
|
|
m_bInitSucc = false; // 初始化状态
|
|
|
m_bExit = false; // 是否退出检测
|
|
|
m_bHaveImgeDet = false;
|
|
|
m_strcameraName = "";
|
|
|
nLastCheckAnalysisyThreadIdx = 0;
|
|
|
m_pChannelFuntion = &m_AnalysisyConfig.checkFunction;
|
|
|
m_pbaseCheckFunction = &m_AnalysisyConfig.baseFunction;
|
|
|
m_nConfigIdx = -1;
|
|
|
m_pdetlog = std::make_shared<DetLog>();
|
|
|
m_pCommonAnalysisyConfig = NULL;
|
|
|
m_imageResultJudge.SetAnalysisyConfig(&m_AnalysisyConfig);
|
|
|
|
|
|
bshowimg = false;
|
|
|
}
|
|
|
|
|
|
CameraCheckAnalysisy::~CameraCheckAnalysisy()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::set_cpu_id(const std::vector<int> &cpu_set_vec)
|
|
|
{
|
|
|
// for cpu affinity
|
|
|
int nRet = 0;
|
|
|
#ifdef __linux
|
|
|
cpu_set_t _cur_cpu_set;
|
|
|
CPU_ZERO(&_cur_cpu_set);
|
|
|
for (auto _id : cpu_set_vec)
|
|
|
{
|
|
|
CPU_SET(_id, &_cur_cpu_set);
|
|
|
}
|
|
|
if (0 > pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &_cur_cpu_set))
|
|
|
{
|
|
|
perror("set cpu affinity failed: ");
|
|
|
printf("Warning: set cpu affinity failed ... ...\n");
|
|
|
nRet = -1;
|
|
|
}
|
|
|
#endif //__linux
|
|
|
return nRet;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::WaitDetImg()
|
|
|
{
|
|
|
std::unique_lock<std::mutex> lk(mtx_WaiteImg);
|
|
|
cond_WaiteImg.wait(lk, [this]()
|
|
|
{ return m_bHaveImgeDet; });
|
|
|
|
|
|
lk.unlock();
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 判断物料在左还是在右
|
|
|
string JudgeMaterialPosition(Mat img) {
|
|
|
if (img.empty()) {
|
|
|
cerr << "Error: Input image is empty!" << endl;
|
|
|
return "Unknown";
|
|
|
}
|
|
|
// 原图可能是彩色,内部统一转灰度计算(形参为副本,不会改动调用方图像)
|
|
|
if (img.channels() != 1) {
|
|
|
cv::Mat grayImg;
|
|
|
if (img.channels() == 4) {
|
|
|
cv::cvtColor(img, grayImg, cv::COLOR_BGRA2GRAY);
|
|
|
} else {
|
|
|
cv::cvtColor(img, grayImg, cv::COLOR_BGR2GRAY);
|
|
|
}
|
|
|
img = grayImg;
|
|
|
}
|
|
|
resize(img, img, Size(img.cols, img.rows * 0.001), 0, 0);
|
|
|
int rows = img.rows;
|
|
|
int cols = img.cols;
|
|
|
// 统计灰度值 < bg_val 的像素数量
|
|
|
int left_black_count = 0;
|
|
|
int right_black_count = 0;
|
|
|
int bg_val = 25;
|
|
|
for (int row = 0; row < rows; ++row) {
|
|
|
for (int col = 0; col < 3; ++col) {
|
|
|
if (img.at<uchar>(row, col) < 25) {
|
|
|
left_black_count++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (int col = cols - 3; col < cols; ++col) {
|
|
|
if (img.at<uchar>(row, col) < 25) {
|
|
|
right_black_count++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 判断物料位置
|
|
|
if (left_black_count <= right_black_count) {
|
|
|
return "Left";
|
|
|
} else if (left_black_count > right_black_count) {
|
|
|
return "Right";
|
|
|
}
|
|
|
else{
|
|
|
return "Unknown";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//正常情况CA（img物料在左，img_B物料在右），TA（img物料在右，img_B物料在左）
|
|
|
bool ifExchange(cv::Mat &img, const cv::Mat &img_B, std::string strcam ){
|
|
|
string img_position = JudgeMaterialPosition(img);
|
|
|
string img_B_position = JudgeMaterialPosition(img_B);
|
|
|
if (strcam == "TA"){
|
|
|
if (img_position == "Left" && img_B_position == "Right"){
|
|
|
return true;
|
|
|
}
|
|
|
else{
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
else{
|
|
|
if (img_position == "Right" && img_B_position == "Left"){
|
|
|
return true;
|
|
|
}
|
|
|
else{
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::Detect_Pre()
|
|
|
{
|
|
|
|
|
|
std::string strlog;
|
|
|
std::string strSN;
|
|
|
std::string strBasic;
|
|
|
|
|
|
strSN = m_pCheck_Result->productBaseResult->strproductName;
|
|
|
strBasic = ">>" + strSN + " cam:" + m_strcameraName;
|
|
|
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s ==================start", strBasic.c_str());
|
|
|
std::shared_ptr<ImageAllResult> pImageResult = m_pCheck_Result->GetNoDetImg();
|
|
|
|
|
|
if (!pImageResult)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
if (!pImageResult->result->in_shareImage->bCam_AB)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s ==================bCam_AB = false", strBasic.c_str());
|
|
|
return 0;
|
|
|
}
|
|
|
if (pImageResult->result->in_shareImage->img.empty() ||
|
|
|
pImageResult->result->in_shareImage->img_B.empty())
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s ==================img.empty() || img_B.empty() ", strBasic.c_str());
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
//判断图片左右,0为左，1为右
|
|
|
bool exchange_img = ifExchange(pImageResult->result->in_shareImage->img, pImageResult->result->in_shareImage->img_B, pImageResult->result->in_shareImage->strCameraName);
|
|
|
if(exchange_img){
|
|
|
std::swap(pImageResult->result->in_shareImage->img, pImageResult->result->in_shareImage->img_B);
|
|
|
}
|
|
|
|
|
|
// printf("===66666666666666666\n");
|
|
|
int re = Mergimg(pImageResult->result->in_shareImage->img, pImageResult->result->in_shareImage->img_B,
|
|
|
pImageResult->result->in_shareImage->strCameraName, pImageResult->result->in_shareImage->strChannel);
|
|
|
|
|
|
if (pImageResult->result->in_shareImage->Det_Mode == DET_MODE_MergeImg)
|
|
|
{
|
|
|
cv::imwrite(pImageResult->result->in_shareImage->strCameraName + "_MergeImg.png", pImageResult->result->in_shareImage->img);
|
|
|
return 2;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::Mergimg(cv::Mat &img, const cv::Mat &img_B, std::string strcam, std::string strchannel)
|
|
|
{
|
|
|
// std::cout << img.size() << std::endl;
|
|
|
// std::cout << img_B.size() << std::endl;
|
|
|
if (img.size() != img_B.size())
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
long t1, t2;
|
|
|
t1 = CheckUtil::getcurTime();
|
|
|
int re = 0;
|
|
|
cv::Rect Left_Roi;
|
|
|
cv::Rect Right_Roi;
|
|
|
cv::Mat AllImg = cv::Mat::zeros(img.rows, img.cols * 2, img.type());
|
|
|
// cv::imwrite(strcam + strchannel + "_img.png", img);
|
|
|
// cv::imwrite(strcam + strchannel + "img_B.png", img_B);
|
|
|
if (strcam == "TA")
|
|
|
{
|
|
|
cv::Rect Left_Tem_Roi;
|
|
|
cv::Point Left_Tem_Point_Up;
|
|
|
cv::Point Left_Tem_Point_Donw;
|
|
|
cv::Rect Right_Tem_Roi;
|
|
|
cv::Point Right_Tem_Point_Up;
|
|
|
cv::Point Right_Tem_Point_Donw;
|
|
|
// left Img
|
|
|
|
|
|
{
|
|
|
re = GetRectAndPoint(img, Left_Tem_Roi, Left_Tem_Point_Up, Left_Tem_Point_Donw, false, strcam, strchannel);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s Mergimg GetRectAndPoint TAA error %d", strcam.c_str(), re);
|
|
|
return 1;
|
|
|
}
|
|
|
re = GetRectAndPoint(img_B, Right_Tem_Roi, Right_Tem_Point_Up, Right_Tem_Point_Donw, true, strcam, strchannel);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s Mergimg GetRectAndPoint TAB error %d", strcam.c_str(), re);
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
img(Left_Tem_Roi).copyTo(AllImg(Left_Tem_Roi));
|
|
|
|
|
|
int hlen_left = Left_Tem_Point_Donw.y - Left_Tem_Point_Up.y;
|
|
|
int hlen_right = Right_Tem_Point_Donw.y - Right_Tem_Point_Up.y;
|
|
|
float fhscle = hlen_left * 1.0f / hlen_right;
|
|
|
int dy = Left_Tem_Point_Up.y - Right_Tem_Point_Up.y;
|
|
|
cv::Rect allroi = Right_Tem_Roi;
|
|
|
allroi.height *= fhscle;
|
|
|
allroi.x = Left_Tem_Roi.x + Left_Tem_Roi.width;
|
|
|
allroi.y += dy;
|
|
|
|
|
|
cv::Size sz;
|
|
|
sz.width = allroi.width;
|
|
|
sz.height = allroi.height;
|
|
|
|
|
|
cv::resize(img_B(Right_Tem_Roi), AllImg(allroi), sz);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cv::Rect Left_Tem_Roi;
|
|
|
cv::Point Left_Tem_Point_Up;
|
|
|
cv::Point Left_Tem_Point_Donw;
|
|
|
cv::Rect Right_Tem_Roi;
|
|
|
cv::Point Right_Tem_Point_Up;
|
|
|
cv::Point Right_Tem_Point_Donw;
|
|
|
// left Img
|
|
|
|
|
|
{
|
|
|
re = GetRectAndPoint(img_B, Left_Tem_Roi, Left_Tem_Point_Up, Left_Tem_Point_Donw, false, strcam, strchannel);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s Mergimg GetRectAndPoint CAA error %d", strcam.c_str(), re);
|
|
|
return 1;
|
|
|
}
|
|
|
re = GetRectAndPoint(img, Right_Tem_Roi, Right_Tem_Point_Up, Right_Tem_Point_Donw, true, strcam, strchannel);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s Mergimg GetRectAndPoint CAB error %d", strcam.c_str(), re);
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
img_B(Left_Tem_Roi).copyTo(AllImg(Left_Tem_Roi));
|
|
|
int hlen_left = Left_Tem_Point_Donw.y - Left_Tem_Point_Up.y;
|
|
|
int hlen_right = Right_Tem_Point_Donw.y - Right_Tem_Point_Up.y;
|
|
|
float fhscle = hlen_left * 1.0f / hlen_right;
|
|
|
int dy = Left_Tem_Point_Up.y - Right_Tem_Point_Up.y;
|
|
|
cv::Rect allroi = Right_Tem_Roi;
|
|
|
allroi.height *= fhscle;
|
|
|
allroi.x = Left_Tem_Roi.x + Left_Tem_Roi.width;
|
|
|
allroi.y += dy;
|
|
|
|
|
|
cv::Size sz;
|
|
|
sz.width = allroi.width;
|
|
|
sz.height = allroi.height;
|
|
|
|
|
|
cv::resize(img(Right_Tem_Roi), AllImg(allroi), sz);
|
|
|
}
|
|
|
}
|
|
|
img = AllImg;
|
|
|
t2 = CheckUtil::getcurTime();
|
|
|
// cv::imwrite(strcam + strchannel + "_merg.png", AllImg);
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Pre", "Cam %s Mergimg use time %ld ms", strcam.c_str(), t2 - t1);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::GetRectAndPoint(const cv::Mat &img, cv::Rect &roi, cv::Point &merg_p_up, cv::Point &merg_p_down, bool bleft, std::string strcam, std::string strchannel)
|
|
|
{
|
|
|
|
|
|
bshowimg = false;
|
|
|
|
|
|
int A_line_up = 0;
|
|
|
int A_line_down = 0;
|
|
|
|
|
|
Edge_Search_Config config;
|
|
|
|
|
|
if (bshowimg)
|
|
|
{
|
|
|
if (img.channels() != 1)
|
|
|
{
|
|
|
showimg = img.clone();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cv::cvtColor(img, showimg, cv::COLOR_GRAY2BGR);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
config.nSearchCount = 10;
|
|
|
config.strchannel = strchannel;
|
|
|
config.directSign = DirectSign_UP;
|
|
|
if (bleft)
|
|
|
{
|
|
|
config.roi = cv::Rect(0, 0, 200, img.rows * 0.8);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
config.roi = cv::Rect(img.cols - 200, 0, 200, img.rows * 0.8);
|
|
|
}
|
|
|
|
|
|
int re123 = GetEdgePoint(img, &config, A_line_up);
|
|
|
if (re123 != 0)
|
|
|
{
|
|
|
printf("DirectSign_UP::111111111111GetEdgePoint111111 A_line_up %d\n", re123);
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
config.directSign = DirectSign_DOWN;
|
|
|
config.strchannel = strchannel + "ccc";
|
|
|
config.roi = cv::Rect(0, img.rows * 0.2, 200, img.rows * 0.8 - 1);
|
|
|
|
|
|
if (bleft)
|
|
|
{
|
|
|
config.roi = cv::Rect(0, img.rows * 0.2, 200, img.rows * 0.8 - 1);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
config.roi = cv::Rect(img.cols - 200, img.rows * 0.2, 200, img.rows * 0.8 - 1);
|
|
|
}
|
|
|
|
|
|
re123 = GetEdgePoint(img, &config, A_line_down);
|
|
|
if (re123 != 0)
|
|
|
{
|
|
|
printf("DirectSign_UP::111111111111GetEdgePoint111111 A_line_down %d\n", re123);
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
{
|
|
|
if (bshowimg)
|
|
|
{
|
|
|
cv::line(showimg, cv::Point(0, A_line_down), cv::Point(img.cols, A_line_down), cv::Scalar(0, 255, 0), 2);
|
|
|
cv::line(showimg, cv::Point(0, A_line_up), cv::Point(img.cols, A_line_up), cv::Scalar(0, 255, 0), 2);
|
|
|
|
|
|
cv::imwrite(strcam + strchannel + "_line.png", showimg);
|
|
|
}
|
|
|
}
|
|
|
// printf("DirectSign_UP::111111111111111111 re123 %d\n", re123);
|
|
|
// getchar();
|
|
|
|
|
|
// 阈值化 + 轮廓提取只支持单通道,彩色原图内部转灰度(不改动调用方图像)
|
|
|
cv::Mat grayImg;
|
|
|
if (img.channels() != 1)
|
|
|
{
|
|
|
if (img.channels() == 4)
|
|
|
{
|
|
|
cv::cvtColor(img, grayImg, cv::COLOR_BGRA2GRAY);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cv::cvtColor(img, grayImg, cv::COLOR_BGR2GRAY);
|
|
|
}
|
|
|
}
|
|
|
const cv::Mat &workImg = (img.channels() == 1) ? img : grayImg;
|
|
|
|
|
|
cv::Mat small, smallbin;
|
|
|
cv::resize(workImg, small, cv::Size(600, 1500));
|
|
|
|
|
|
cv::threshold(small, smallbin, 15, 255,
|
|
|
cv::THRESH_BINARY);
|
|
|
|
|
|
/* 3. contours */
|
|
|
std::vector<std::vector<cv::Point>> contours;
|
|
|
cv::findContours(smallbin, contours,
|
|
|
cv::RETR_EXTERNAL,
|
|
|
cv::CHAIN_APPROX_SIMPLE);
|
|
|
|
|
|
if (contours.empty())
|
|
|
return 1;
|
|
|
|
|
|
/* 4. max contour */
|
|
|
double maxArea = 0;
|
|
|
int idx = -1;
|
|
|
for (int i = 0; i < contours.size(); i++)
|
|
|
{
|
|
|
double area = cv::contourArea(contours[i]);
|
|
|
if (area > maxArea)
|
|
|
{
|
|
|
maxArea = area;
|
|
|
idx = i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (idx < 0)
|
|
|
return 1;
|
|
|
|
|
|
cv::Rect rSmall = cv::boundingRect(contours[idx]);
|
|
|
|
|
|
/* 5. map to original */
|
|
|
float sx = (float)workImg.cols / smallbin.cols;
|
|
|
float sy = (float)workImg.rows / smallbin.rows;
|
|
|
cv::Rect rectInSrc;
|
|
|
|
|
|
rectInSrc.x = int(rSmall.x * sx) - 50;
|
|
|
rectInSrc.y = int(rSmall.y * sy) - 50;
|
|
|
rectInSrc.width = int(rSmall.width * sx) + 100;
|
|
|
rectInSrc.height = int(rSmall.height * sy) + 100;
|
|
|
|
|
|
if (rectInSrc.y >= A_line_up)
|
|
|
{
|
|
|
rectInSrc.y = A_line_up - 5;
|
|
|
}
|
|
|
if (rectInSrc.y + rectInSrc.height <= A_line_down)
|
|
|
{
|
|
|
rectInSrc.height = A_line_down + 5 - rectInSrc.y;
|
|
|
}
|
|
|
|
|
|
if (rectInSrc.x < 0)
|
|
|
rectInSrc.x = 0;
|
|
|
if (rectInSrc.y < 0)
|
|
|
rectInSrc.y = 0;
|
|
|
if (rectInSrc.x + rectInSrc.width > workImg.cols)
|
|
|
rectInSrc.width = workImg.cols - rectInSrc.x;
|
|
|
if (rectInSrc.y + rectInSrc.height > workImg.rows)
|
|
|
{
|
|
|
rectInSrc.height = workImg.rows - rectInSrc.y;
|
|
|
}
|
|
|
|
|
|
merg_p_up.y = A_line_up;
|
|
|
merg_p_up.x = workImg.cols;
|
|
|
merg_p_down.y = A_line_down;
|
|
|
merg_p_down.x = workImg.cols;
|
|
|
roi = rectInSrc;
|
|
|
|
|
|
if (bshowimg)
|
|
|
{
|
|
|
cv::rectangle(showimg, rectInSrc, cv::Scalar(0, 0, 255), 2);
|
|
|
cv::imwrite(strcam + strchannel + "_rect.png", showimg);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 对该相机下的每一张图片进行处理
|
|
|
int CameraCheckAnalysisy::Detect_Images()
|
|
|
{
|
|
|
|
|
|
std::string strlog;
|
|
|
std::string strSN;
|
|
|
std::string strBasic;
|
|
|
|
|
|
strSN = m_pCheck_Result->productBaseResult->strproductName;
|
|
|
strBasic = ">>" + strSN + " cam:" + m_strcameraName;
|
|
|
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Images", "Cam %s ==================start", strBasic.c_str());
|
|
|
// // 循环处理每个图片
|
|
|
bool bcomplete = false;
|
|
|
long time_No_CheckAnalysisy = 30 * 1000;
|
|
|
long ts = CheckUtil::getcurTime();
|
|
|
while (!bcomplete)
|
|
|
{
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
ImgCheckBase *pImgCheckAnalysisy = NULL;
|
|
|
long t1 = CheckUtil::getcurTime();
|
|
|
|
|
|
// 拿到计算资源
|
|
|
while (true)
|
|
|
{
|
|
|
|
|
|
pImgCheckAnalysisy = GetDealResult(-1);
|
|
|
if (pImgCheckAnalysisy != NULL)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20)); //
|
|
|
long t2 = CheckUtil::getcurTime();
|
|
|
// 如果 超过秒XX都没有拿到处理资源，则直接退出
|
|
|
if (t2 - t1 > time_No_CheckAnalysisy)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_2, "Detect_Images", "Error %ld ms No pImgCheckAnalysisy", time_No_CheckAnalysisy);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 没有分析检测资源，直接退出
|
|
|
if (pImgCheckAnalysisy == NULL)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
// 1、把每张图都进行AI 推理 获得 blob 结果
|
|
|
std::shared_ptr<ImageAllResult> pImageResult = m_pCheck_Result->GetNoDetImg();
|
|
|
bool bHaveNotdetImg = false;
|
|
|
// 没有未检测的图片了。
|
|
|
if (pImageResult)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_2, "Detect_Images", "channel %s send det ", pImageResult->strChannel.c_str());
|
|
|
bHaveNotdetImg = true;
|
|
|
pImgCheckAnalysisy->SetDataRun_SharePtr(pImageResult);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 图片都已经送完了。
|
|
|
if (m_pCheck_Result->getImgPushComplate())
|
|
|
{
|
|
|
// printf("Cam Detect_Images %s ==================send end \n", strBasic.c_str());
|
|
|
// 没有图在进行 检测了。
|
|
|
bool bhavedet = false;
|
|
|
for (int i = 0; i < IMGCHECKANALYSISY_NUM; i++)
|
|
|
{
|
|
|
if (CHECK_THREAD_STATUS_IDLE != m_pImgCheckAnalysisy[i]->GetStatus())
|
|
|
{
|
|
|
bhavedet = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
// printf("Cam Detect_Images %s ==================bhavedet %d\n", strBasic.c_str(), bhavedet);
|
|
|
if (!bhavedet)
|
|
|
{
|
|
|
bcomplete = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// printf("Cam Detect_Images %s ==================No send end\n", strBasic.c_str() );
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
long te = CheckUtil::getcurTime();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "Detect_Images", "Cam %s =====ALL image det complate time %ld ms=============End", strBasic.c_str(), te - ts);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::ResultParamJudge()
|
|
|
{
|
|
|
//==================================================
|
|
|
//======= 适用于 单相机或多相机，每个相机之间的图相互没关系。
|
|
|
//=======
|
|
|
//=======
|
|
|
//=======
|
|
|
//==================================================
|
|
|
|
|
|
std::string strlog;
|
|
|
std::string strSN;
|
|
|
std::string strBasic;
|
|
|
long ts = CheckUtil::getcurTime();
|
|
|
|
|
|
int ImageNum = m_pCheck_Result->ImageALLDetResultList.size();
|
|
|
if (ImageNum <= 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", "Error ImageNum <=0");
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
// 如果 参数是空，直接返回。
|
|
|
if (m_pCommonAnalysisyConfig == NULL)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", "Error m_pCommonAnalysisyConfig == NULL");
|
|
|
return 1;
|
|
|
}
|
|
|
int regionNum = m_pCommonAnalysisyConfig->regionConfigArr.size();
|
|
|
if (regionNum <= 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", "Error Config region num = 0");
|
|
|
}
|
|
|
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", "==================start image Num %d region num %d", ImageNum, regionNum);
|
|
|
|
|
|
// 对每个图片通道进行单独分析
|
|
|
for (int imgidx = 0; imgidx < ImageNum; imgidx++)
|
|
|
{
|
|
|
long t1 = CheckUtil::getcurTime();
|
|
|
int re = m_imageResultJudge.ResultJudge(m_pCheck_Result->ImageALLDetResultList.at(imgidx));
|
|
|
long t2 = CheckUtil::getcurTime();
|
|
|
m_imageResultJudge.DrawResult(m_pCheck_Result->ImageALLDetResultList.at(imgidx));
|
|
|
long t3 = CheckUtil::getcurTime();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", " det time %ld ms judge %ld draw %ld", t3 - t1, t2 - t1, t3 - t2);
|
|
|
|
|
|
// 把结果转成 json 保存。 用以复测
|
|
|
std::shared_ptr<CheckResult> m_CheckResult_shareP = m_pCheck_Result->ImageALLDetResultList.at(imgidx)->result;
|
|
|
m_CheckResult_shareP->strResultJson = m_CheckResultJson.GetResultString(m_pCheck_Result->ImageALLDetResultList.at(imgidx)->pDetResult);
|
|
|
}
|
|
|
long te = CheckUtil::getcurTime();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "ResultParamJudge", "==================End time %ld ms ", te - ts);
|
|
|
|
|
|
// m_pdetlog->printLog(m_strcameraName);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::Init(std::string strcameraName)
|
|
|
{
|
|
|
m_strcameraName = strcameraName;
|
|
|
printf("CameraCheckAnalysisy::Init start \n");
|
|
|
SetNewConfig();
|
|
|
|
|
|
int re = 0;
|
|
|
re = InitCheckAnalysisy();
|
|
|
if (CHECK_OK != re)
|
|
|
{
|
|
|
printf("InitCheckAnalysisy error\n");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
re = InitRun();
|
|
|
if (CHECK_OK != re)
|
|
|
{
|
|
|
printf("InitRun error\n");
|
|
|
m_nErrorCode = re;
|
|
|
return m_nErrorCode;
|
|
|
}
|
|
|
|
|
|
printf("CameraCheckAnalysisy::Init end \n");
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CameraCheckAnalysisy::SetTplInfo(const cv::RotatedRect &outerRect)
|
|
|
{
|
|
|
for (int i = 0; i < IMGCHECKANALYSISY_NUM; i++)
|
|
|
{
|
|
|
auto *p = static_cast<ImgCheckAnalysisy *>(m_pImgCheckAnalysisy[i]);
|
|
|
if (p)
|
|
|
{
|
|
|
p->SetTplInfo(outerRect);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::StartCheck(std::shared_ptr<CameraResult> pCamera_Check_Result)
|
|
|
{
|
|
|
if (m_bHaveImgeDet)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(mtx_WaiteImg);
|
|
|
m_pCheck_Result = pCamera_Check_Result;
|
|
|
if (m_pCheck_Result->bJson)
|
|
|
{
|
|
|
// 如果是 复测 直接进入 参数判断阶段。
|
|
|
m_pCheck_Result->SetCheckStep(Check_Step_ResultParamJudg); // 进入预处理阶段
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pCheck_Result->SetCheckStep(Check_Step_PreDet); // 进入预处理阶段
|
|
|
}
|
|
|
|
|
|
m_bHaveImgeDet = true;
|
|
|
m_pdetlog = m_pCheck_Result->detlog;
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "StartCheck", "==================start %s", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
}
|
|
|
cond_WaiteImg.notify_all();
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::StartThread()
|
|
|
{
|
|
|
m_bExit = false;
|
|
|
// 开启检测线程
|
|
|
ptr_thread_Run = std::make_shared<std::thread>(std::bind(&CameraCheckAnalysisy::Run, this));
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::StopThread()
|
|
|
{
|
|
|
m_bExit = true;
|
|
|
if (ptr_thread_Run != nullptr)
|
|
|
{
|
|
|
if (ptr_thread_Run->joinable())
|
|
|
{
|
|
|
ptr_thread_Run->join();
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::InitRun()
|
|
|
{
|
|
|
int re;
|
|
|
re = StartThread();
|
|
|
if (CHECK_OK != re)
|
|
|
{
|
|
|
return re;
|
|
|
}
|
|
|
m_bInitSucc = true;
|
|
|
// 检测前更新参数
|
|
|
SetNewConfig();
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::InitCheckAnalysisy()
|
|
|
{
|
|
|
int re = 0;
|
|
|
// 全局递增的 CPU 核偏移：
|
|
|
static std::atomic<int> s_cpuOffset{0};
|
|
|
for (int i = 0; i < IMGCHECKANALYSISY_NUM; i++)
|
|
|
{
|
|
|
RunInfoST RunConfig;
|
|
|
RunConfig.nThreadIdx = i;
|
|
|
{
|
|
|
// 核带下沉到库内部：不再依赖调用方传入的 nCpu_start_Idx / nCpu_num
|
|
|
int offset = s_cpuOffset.fetch_add(1) % CHECK_CPU_BAND_NUM;
|
|
|
RunConfig.nCpu_start_Idx = CHECK_CPU_BAND_START + offset;
|
|
|
}
|
|
|
RunConfig.nCpu_num = 1;
|
|
|
|
|
|
m_pImgCheckAnalysisy[i] = ImgCheckBase::GetInstance();
|
|
|
re = m_pImgCheckAnalysisy[i]->UpdateConfig((void *)&RunConfig, CHECK_CONFIG_Run);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
printf("UpdateConfig %d Fail %s\n", CHECK_CONFIG_Run, m_pImgCheckAnalysisy[i]->GetErrorInfo().c_str());
|
|
|
return re;
|
|
|
}
|
|
|
re = m_pImgCheckAnalysisy[i]->UpdateConfig((void *)m_pConfig.get(), CHECK_CONFIG_Module);
|
|
|
if (re != 0)
|
|
|
{
|
|
|
printf("UpdateConfig %d Fail %s\n", CHECK_CONFIG_Module, m_pImgCheckAnalysisy[i]->GetErrorInfo().c_str());
|
|
|
return re;
|
|
|
}
|
|
|
|
|
|
re = m_pImgCheckAnalysisy[i]->RunStart();
|
|
|
if (re != 0)
|
|
|
{
|
|
|
printf("cami %s RunStart Fail ==%d\n", m_strcameraName.c_str(), re);
|
|
|
return re;
|
|
|
}
|
|
|
// printf(">>>>cami %s InitCheckAnalysisy: ImgCheckThread %d / %d Start Succ \n", m_strcameraName.c_str(), i+1, IMGCHECKANALYSISY_NUM);
|
|
|
|
|
|
if (re != 0)
|
|
|
{
|
|
|
return re;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::CheckImgRun()
|
|
|
{
|
|
|
|
|
|
int re = 0;
|
|
|
Check_Step curcheckStep = m_pCheck_Result->GetCheckStep();
|
|
|
m_pdetlog->bPrintStr = false;
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "------------curcheckStep:%d ", curcheckStep);
|
|
|
// 如果是未检测状态，则开始预处理
|
|
|
if (curcheckStep == Check_Step_NODet)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "Error curcheckStep = NODet ");
|
|
|
return 1;
|
|
|
}
|
|
|
// 检测前更新参数
|
|
|
SetNewConfig();
|
|
|
// 预处理
|
|
|
if (curcheckStep == Check_Step_PreDet)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_PreDet", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
re = Detect_Pre();
|
|
|
if (re != 0)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_PreDet error = %d", m_pCheck_Result->cameraBaseResult->strCameraName.c_str(), re);
|
|
|
curcheckStep = Check_Step_ImgeDet_End; // 进入到预图片检测阶段
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
curcheckStep = Check_Step_ImgeDet; // 进入到预图片检测阶段
|
|
|
}
|
|
|
|
|
|
m_pCheck_Result->SetCheckStep(curcheckStep);
|
|
|
}
|
|
|
|
|
|
// 检测每张图片
|
|
|
if (curcheckStep == Check_Step_ImgeDet)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_ImgeDet", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
// 检测每张图片
|
|
|
re = Detect_Images();
|
|
|
curcheckStep = Check_Step_ResultParamJudg; // 进入到预图片检测阶段
|
|
|
m_pCheck_Result->SetCheckStep(curcheckStep);
|
|
|
}
|
|
|
|
|
|
// 对检测结果进行参数判断，判断是否NG.
|
|
|
if (curcheckStep == Check_Step_ResultParamJudg)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_ResultParamJudg", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
// 检测每张图片
|
|
|
re = ResultParamJudge();
|
|
|
// 如果有异常
|
|
|
if (re != 0)
|
|
|
{
|
|
|
// 图片 送图没有完成，则继续等待。
|
|
|
if (!m_pCheck_Result->getImgPushComplate())
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
curcheckStep = Check_Step_ImgeDet_End; // 进入到预图片检测阶段
|
|
|
m_pCheck_Result->SetCheckStep(curcheckStep);
|
|
|
}
|
|
|
|
|
|
if (curcheckStep == Check_Step_ImgeDet_End)
|
|
|
{
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_ImgeDet_End", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
|
|
|
// 所有图片都送完了。
|
|
|
if (m_pCheck_Result->getImgPushComplate())
|
|
|
{
|
|
|
curcheckStep = Check_Step_Complete; // 进入到预图片检测阶段
|
|
|
// 注意：这里先不发布 Check_Step_Complete。
|
|
|
// 若提前发布，ALLImgCheckAnalysisy 线程会立刻把结果塞给 deal，
|
|
|
// 而本线程还在 InsertCameraLog() 里写 result->det_LogList，两边并发（读/写）竞争。
|
|
|
// 因此把 SetCheckStep(Check_Step_Complete) 挪到 InsertCameraLog() 之后。
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("========came %s wait img send end \n", m_strcameraName.c_str());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 检测完成，
|
|
|
if (curcheckStep == Check_Step_Complete)
|
|
|
{
|
|
|
long tend = CheckUtil::getcurTime();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "cam %s : Check_Step_Complete", m_pCheck_Result->cameraBaseResult->strCameraName.c_str());
|
|
|
std::string strTimg = CheckUtil::getCurTimeHMS();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_0, "CheckImgRun", "========came %s Check ALL end time %ld ms %s",
|
|
|
m_pCheck_Result->cameraBaseResult->strCameraName.c_str(), tend - m_pCheck_Result->time_start, strTimg.c_str());
|
|
|
InsertCameraLog();
|
|
|
// 日志拼接完成后再发布“检测完成”，避免 deal 提前读到正在写入的 det_LogList
|
|
|
m_pCheck_Result->SetCheckStep(Check_Step_Complete);
|
|
|
std::lock_guard<std::mutex> lock(mtx_WaiteImg);
|
|
|
m_bHaveImgeDet = false;
|
|
|
|
|
|
m_pCheck_Result.reset();
|
|
|
}
|
|
|
// m_pdetlog->printLog(m_strcameraName);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::Run()
|
|
|
{
|
|
|
|
|
|
while (!m_bExit)
|
|
|
{
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
WaitDetImg();
|
|
|
int re = CheckImgRun();
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::ImgEdge(cv::Mat img, cv::Mat &detMaskImg, cv::Rect &roi, int productIdx)
|
|
|
{
|
|
|
int re = 0;
|
|
|
|
|
|
return re;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::InsertCameraLog()
|
|
|
{
|
|
|
|
|
|
int ImageNum = m_pCheck_Result->ImageALLDetResultList.size();
|
|
|
for (int imgidx = 0; imgidx < ImageNum; imgidx++)
|
|
|
{
|
|
|
|
|
|
std::shared_ptr<ImageAllResult> pImageResult = m_pCheck_Result->ImageALLDetResultList.at(imgidx);
|
|
|
std::shared_ptr<CheckResult> m_CheckResult_shareP = pImageResult->result; // 返回结果
|
|
|
if (!m_CheckResult_shareP || !pImageResult)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 1、把图片的相关日志 写到 返回 日志中。
|
|
|
// 注意：DetLog 可能仍被实例线程写入，使用 GetLogs() 做加锁快照，避免并发遍历。
|
|
|
{
|
|
|
std::vector<std::string> imgLogs = pImageResult->detlog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
imgLogs.begin(), imgLogs.end());
|
|
|
}
|
|
|
std::string str = "";
|
|
|
char buffer[256];
|
|
|
// 2、把缺陷信息 写的 返回日志中。
|
|
|
{
|
|
|
|
|
|
std::shared_ptr<One_Image_CheckResult_> pDetResult = pImageResult->pDetResult; // 检测结果
|
|
|
if (!pDetResult)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (!pDetResult->pQx_ErrorList)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
int qxNum = pDetResult->pQx_ErrorList->size();
|
|
|
|
|
|
// Add NG log
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================NG num %d=============================", pImageResult->NG_num);
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
for (int qxidx = 0; qxidx < qxNum; qxidx++)
|
|
|
{
|
|
|
QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
|
|
|
|
|
|
if (QX_info->result == QX_RESULT_TYPE_NG)
|
|
|
{
|
|
|
std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;
|
|
|
std::vector<std::string> qxLogs = pQxLog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
qxLogs.begin(), qxLogs.end());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================YS num %d=============================", pImageResult->YS_num);
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
for (int qxidx = 0; qxidx < qxNum; qxidx++)
|
|
|
{
|
|
|
QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
|
|
|
|
|
|
if (QX_info->result == QX_RESULT_TYPE_YS)
|
|
|
{
|
|
|
std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;
|
|
|
std::vector<std::string> qxLogs = pQxLog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
qxLogs.begin(), qxLogs.end());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================OK num %d=============================", pImageResult->Ok_num);
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
for (int qxidx = 0; qxidx < qxNum; qxidx++)
|
|
|
{
|
|
|
QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
|
|
|
|
|
|
if (QX_info->result == QX_RESULT_TYPE_OK)
|
|
|
{
|
|
|
std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;
|
|
|
std::vector<std::string> qxLogs = pQxLog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
qxLogs.begin(), qxLogs.end());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================NO Judge num %d=============================", pImageResult->NoJudge_num);
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
for (int qxidx = 0; qxidx < qxNum; qxidx++)
|
|
|
{
|
|
|
QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
|
|
|
|
|
|
if (QX_info->result == QX_RESULT_TYPE_NoJduge)
|
|
|
{
|
|
|
std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;
|
|
|
std::vector<std::string> qxLogs = pQxLog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
qxLogs.begin(), qxLogs.end());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================Cam Log =============================");
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
|
|
|
// 3、把相机的日志 写到 返回日志中。
|
|
|
{
|
|
|
std::vector<std::string> camLogs = m_pCheck_Result->detlog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
camLogs.begin(), camLogs.end());
|
|
|
}
|
|
|
|
|
|
{
|
|
|
sprintf(buffer, " =====================Product Log =============================");
|
|
|
str = buffer;
|
|
|
m_CheckResult_shareP->det_LogList.push_back(str);
|
|
|
}
|
|
|
// 4、把产品相关日志 写到 返回日志中。
|
|
|
{
|
|
|
std::vector<std::string> productLogs = m_pCheck_Result->productBaseResult->detlog->GetLogs();
|
|
|
m_CheckResult_shareP->det_LogList.insert(m_CheckResult_shareP->det_LogList.end(),
|
|
|
productLogs.begin(), productLogs.end());
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
ChannelCheckFunction *CameraCheckAnalysisy::GetChannelFuntion(std::string strChannelName)
|
|
|
{
|
|
|
ChannelCheckFunction *p = NULL;
|
|
|
// printf("m_pChannelFuntion->channelFunctionArr.size() %zu\n", m_pChannelFuntion->channelFunctionArr.size());
|
|
|
for (int i = 0; i < m_pChannelFuntion->channelFunctionArr.size(); i++)
|
|
|
{
|
|
|
if (CheckUtil::compareIgnoreCase(m_pChannelFuntion->channelFunctionArr[i].strChannelName, strChannelName))
|
|
|
{
|
|
|
p = &m_pChannelFuntion->channelFunctionArr[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return p;
|
|
|
}
|
|
|
int CameraCheckAnalysisy::SetNewConfig()
|
|
|
{
|
|
|
|
|
|
if (m_pConfig.get() == nullptr)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
if (m_nConfigIdx < 0)
|
|
|
{
|
|
|
m_nConfigIdx = m_pConfig->GetConfigIdx();
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "update config", "CameraCheckAnalysisy:%s m_nConfigIdx %d", m_strcameraName.c_str(), m_nConfigIdx);
|
|
|
}
|
|
|
|
|
|
if (m_pConfig->GetConfigUpdataStatus(ConfigType_Analysisy_Common_XL, m_nConfigIdx))
|
|
|
{
|
|
|
m_pConfig->GetConfig(ConfigType_Analysisy_Common_XL, &m_AnalysisyConfig);
|
|
|
if (m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.size() > 0)
|
|
|
{
|
|
|
m_pCommonAnalysisyConfig = &m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(0);
|
|
|
m_imageResultJudge.UpdateConfig();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_pCommonAnalysisyConfig = NULL;
|
|
|
printf("m_AnalysisyConfig.commonCheckConfig.nodeConfigArr == 0 \n");
|
|
|
}
|
|
|
m_pdetlog->AddCheckstr(PrintLevel_1, "update config", "Get New analysisy config");
|
|
|
// printf("*******ALLImgCheckAnalysisy m_pConfig*********************** Update GetConfig \n");
|
|
|
// m_AnalysisyConfig.checkFunction.print("Update GetConfig");
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::preDet_ZF(std::shared_ptr<ImageDetconfig> p, std::shared_ptr<ImageDetResult> &pResult)
|
|
|
{
|
|
|
ImgCheckBase *pImgCheckAnalysisy = NULL;
|
|
|
long t1 = CheckUtil::getcurTime();
|
|
|
int outTime = 1000 * 5;
|
|
|
while (true)
|
|
|
{
|
|
|
|
|
|
pImgCheckAnalysisy = GetDealResult(-1);
|
|
|
if (pImgCheckAnalysisy != NULL)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
long t2 = CheckUtil::getcurTime();
|
|
|
// 超时
|
|
|
if (t2 - t1 > outTime)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 模拟消费过程
|
|
|
}
|
|
|
p->pBaseImgCheckConfig->imgtype = 1;
|
|
|
pImgCheckAnalysisy->CheckImg(p, pResult);
|
|
|
p->pBaseImgCheckConfig->imgtype = 0;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
ImgCheckBase *CameraCheckAnalysisy::GetDealResult(int idx)
|
|
|
{
|
|
|
|
|
|
// 特殊情况
|
|
|
if (idx >= 0 && idx < IMGCHECKANALYSISY_NUM)
|
|
|
{
|
|
|
|
|
|
if (CHECK_THREAD_STATUS_IDLE == m_pImgCheckAnalysisy[idx]->GetStatus())
|
|
|
{
|
|
|
// printf("*-*-*-*-*-*-*-*- use m_pImgCheckAnalysisy %d \n", idx);
|
|
|
return m_pImgCheckAnalysisy[idx];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return NULL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int re = 0;
|
|
|
|
|
|
int nidx = nLastCheckAnalysisyThreadIdx;
|
|
|
|
|
|
for (int i = 0; i < IMGCHECKANALYSISY_NUM; i++)
|
|
|
{
|
|
|
if (nidx >= IMGCHECKANALYSISY_NUM)
|
|
|
{
|
|
|
nidx = 0;
|
|
|
}
|
|
|
if (CHECK_THREAD_STATUS_IDLE == m_pImgCheckAnalysisy[nidx]->GetStatus())
|
|
|
{
|
|
|
nLastCheckAnalysisyThreadIdx = nidx + 1;
|
|
|
// printf("*-*-*-*-*-*-*-*- use m_pImgCheckAnalysisy %d \n", nidx);
|
|
|
return m_pImgCheckAnalysisy[nidx];
|
|
|
}
|
|
|
nidx++;
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::GetEdgePoint(const cv::Mat &imgSrc, Edge_Search_Config *pEdge_Search_Config, int &outP)
|
|
|
{
|
|
|
bool bdbuge = false;
|
|
|
bdbuge = bshowimg;
|
|
|
if (imgSrc.empty())
|
|
|
{
|
|
|
return -11;
|
|
|
}
|
|
|
// 边缘搜索仅支持单通道;彩色/BGRA 原图在此内部转灰度(不改动调用方图像)
|
|
|
cv::Mat grayImg;
|
|
|
if (imgSrc.channels() != 1)
|
|
|
{
|
|
|
if (imgSrc.channels() == 4)
|
|
|
{
|
|
|
cv::cvtColor(imgSrc, grayImg, cv::COLOR_BGRA2GRAY);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cv::cvtColor(imgSrc, grayImg, cv::COLOR_BGR2GRAY);
|
|
|
}
|
|
|
}
|
|
|
const cv::Mat &img = (imgSrc.channels() == 1) ? imgSrc : grayImg;
|
|
|
// 检查roi;
|
|
|
if (!CheckUtil::RoiInImg(pEdge_Search_Config->roi, img))
|
|
|
{
|
|
|
return -13;
|
|
|
}
|
|
|
if (!pEdge_Search_Config->CheckConfigValid())
|
|
|
{
|
|
|
return -14;
|
|
|
}
|
|
|
std::vector<cv::Point> pointList;
|
|
|
bool search_UP_DOWN = false;
|
|
|
cv::Rect roi = pEdge_Search_Config->roi;
|
|
|
int sx = roi.x;
|
|
|
int ex = roi.x + roi.width;
|
|
|
int sy = roi.y;
|
|
|
int ey = roi.y + roi.height;
|
|
|
|
|
|
int nSearchLen = roi.width; // 搜索区域的长度
|
|
|
int nCurPoint_Step = pEdge_Search_Config->stepCount; // 当前点搜索的步长
|
|
|
|
|
|
// 搜索小范围确认
|
|
|
int nhalfrang = (int)pEdge_Search_Config->nSearchrange / 2;
|
|
|
int nrange_start = 0 - nhalfrang;
|
|
|
int nrange_end = 0 - nhalfrang;
|
|
|
int num = 0;
|
|
|
while (true)
|
|
|
{
|
|
|
num++;
|
|
|
nrange_end++;
|
|
|
if (num >= pEdge_Search_Config->nSearchrange)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
// 判断方向
|
|
|
switch (pEdge_Search_Config->directSign)
|
|
|
{
|
|
|
case DirectSign_UP:
|
|
|
search_UP_DOWN = true;
|
|
|
nSearchLen = roi.width;
|
|
|
sx = roi.x;
|
|
|
ex = roi.x + roi.width;
|
|
|
sy = roi.y;
|
|
|
ey = roi.y + roi.height;
|
|
|
nCurPoint_Step = pEdge_Search_Config->stepCount;
|
|
|
break;
|
|
|
case DirectSign_DOWN:
|
|
|
search_UP_DOWN = true;
|
|
|
nSearchLen = roi.width;
|
|
|
nCurPoint_Step = -pEdge_Search_Config->stepCount;
|
|
|
|
|
|
sx = roi.x;
|
|
|
ex = roi.x + roi.width;
|
|
|
sy = roi.y + roi.height - 1;
|
|
|
ey = roi.y;
|
|
|
break;
|
|
|
case DirectSign_Left:
|
|
|
nSearchLen = roi.height;
|
|
|
search_UP_DOWN = false;
|
|
|
nCurPoint_Step = pEdge_Search_Config->stepCount;
|
|
|
|
|
|
sx = roi.x;
|
|
|
ex = roi.x + roi.width;
|
|
|
sy = roi.y;
|
|
|
ey = roi.y + roi.height;
|
|
|
break;
|
|
|
case DirectSign_Right:
|
|
|
nSearchLen = roi.height;
|
|
|
search_UP_DOWN = false;
|
|
|
nCurPoint_Step = -pEdge_Search_Config->stepCount;
|
|
|
|
|
|
sx = roi.x + roi.width - 1;
|
|
|
ex = roi.x;
|
|
|
sy = roi.y;
|
|
|
ey = roi.y + roi.height;
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// 搜索 点数
|
|
|
int nSearchPointNum = pEdge_Search_Config->nSearchCount;
|
|
|
// 搜素点的间隔
|
|
|
int nSearchPointStep = 1;
|
|
|
if (nSearchPointNum > 1)
|
|
|
{
|
|
|
nSearchPointStep = int(nSearchLen * 1.0f / (nSearchPointNum - 1));
|
|
|
}
|
|
|
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::rectangle(showimg, roi, cv::Scalar(255, 0, 0), 2);
|
|
|
printf("nSearchPointStep %d nCurPoint_Step %d,nrange_start %d %d\n", nSearchPointStep, nCurPoint_Step, nrange_start, nrange_end);
|
|
|
}
|
|
|
|
|
|
uchar *pdata = (uchar *)img.data;
|
|
|
int offt = 0;
|
|
|
// 搜索 上下边
|
|
|
if (search_UP_DOWN)
|
|
|
{
|
|
|
// 每个搜索点 分布在X方向。
|
|
|
for (int x = sx; x < ex; x = x + nSearchPointStep)
|
|
|
{
|
|
|
int bOKNum = 0;
|
|
|
int cur_x = x;
|
|
|
int cur_y = sy;
|
|
|
bool bSucc = false;
|
|
|
int succ_y = 0;
|
|
|
|
|
|
// 对每个搜索点进行 y方向搜索
|
|
|
for (int y = sy;; y = y + nCurPoint_Step)
|
|
|
{
|
|
|
|
|
|
if (y < 0 || y >= img.rows)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
//
|
|
|
if (nCurPoint_Step > 0 && y > ey)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
if (nCurPoint_Step < 0 && y < ey)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
offt = y * img.cols;
|
|
|
int range_okNum = 0;
|
|
|
// 对一定范围的点进行判断
|
|
|
for (int k = nrange_start; k < nrange_end; k++)
|
|
|
{
|
|
|
int rangeX = x + k;
|
|
|
if (rangeX < 0 || rangeX >= img.cols)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
offt += rangeX;
|
|
|
if (offt < 0 || offt >= img.cols * img.rows)
|
|
|
{
|
|
|
printf("rangeX %d nCurPoint_Step %d off %d x %d y %d sy %d ey %d %d %d\n", rangeX, nCurPoint_Step, offt, x, y, sy, ey, img.cols, img.rows);
|
|
|
}
|
|
|
|
|
|
if (pdata[offt] >= pEdge_Search_Config->nValueThreshold) // 找到
|
|
|
{
|
|
|
range_okNum++;
|
|
|
}
|
|
|
}
|
|
|
if (range_okNum >= pEdge_Search_Config->nSearchrange)
|
|
|
{
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, cv::Point(x, y), 1, cv::Scalar(0, 0, 255));
|
|
|
}
|
|
|
if (bOKNum == 0)
|
|
|
{
|
|
|
cur_y = y;
|
|
|
}
|
|
|
|
|
|
bOKNum++;
|
|
|
|
|
|
// 连续搜索到 满足要求的点。
|
|
|
if (bOKNum >= pEdge_Search_Config->nLimit)
|
|
|
{
|
|
|
bSucc = true;
|
|
|
succ_y = y;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 如果有间断，需要重新计算连续情况。
|
|
|
bOKNum = 0;
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, cv::Point(x, y), 1, cv::Scalar(0, 255, 0));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (bSucc)
|
|
|
{
|
|
|
cv::Point p(cur_x, cur_y);
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, p, 3, cv::Scalar(255, 0, 0));
|
|
|
}
|
|
|
pointList.push_back(p);
|
|
|
|
|
|
if (pointList.size() > 5)
|
|
|
{
|
|
|
// printf("=============feeeee\n");
|
|
|
sy = succ_y - 100;
|
|
|
ey = succ_y + 100;
|
|
|
if (sy < 0)
|
|
|
{
|
|
|
sy = 0;
|
|
|
}
|
|
|
if (ey >= img.rows)
|
|
|
{
|
|
|
ey = img.rows - 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else // 搜索 左右边
|
|
|
{
|
|
|
// 每个搜索点 分布在X方向。
|
|
|
for (int y = sy; y < ey; y = y + nSearchPointStep)
|
|
|
{
|
|
|
int bOKNum = 0;
|
|
|
int cur_x = sx;
|
|
|
int cur_y = y;
|
|
|
bool bSucc = false;
|
|
|
int succ_x = 0;
|
|
|
|
|
|
// 对每个搜索点进行 y方向搜索
|
|
|
for (int x = sx;; x = x + nCurPoint_Step)
|
|
|
{
|
|
|
if (x < 0 || x >= img.cols)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
//
|
|
|
if (nCurPoint_Step > 0 && x > ex)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
if (nCurPoint_Step < 0 && x < ex)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
int range_okNum = 0;
|
|
|
// 对一定范围的点进行判断
|
|
|
for (int k = nrange_start; k < nrange_end; k++)
|
|
|
{
|
|
|
int rangey = y + k;
|
|
|
if (rangey < 0 || rangey >= img.rows)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
offt = rangey * img.cols + x;
|
|
|
if (offt < 0 || offt >= img.cols * img.rows)
|
|
|
{
|
|
|
printf("rangey %d off %d x %d y %d ey %d %d %d\n", rangey, offt, x, y, ey, img.cols, img.rows);
|
|
|
}
|
|
|
if (pdata[offt] >= pEdge_Search_Config->nValueThreshold) // 找到
|
|
|
{
|
|
|
range_okNum++;
|
|
|
}
|
|
|
}
|
|
|
if (range_okNum >= pEdge_Search_Config->nSearchrange)
|
|
|
{
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, cv::Point(x, y), 1, cv::Scalar(0, 0, 255));
|
|
|
}
|
|
|
if (bOKNum == 0)
|
|
|
{
|
|
|
cur_x = x;
|
|
|
}
|
|
|
|
|
|
bOKNum++;
|
|
|
// 连续搜索到 满足要求的点。
|
|
|
if (bOKNum >= pEdge_Search_Config->nLimit)
|
|
|
{
|
|
|
bSucc = true;
|
|
|
succ_x = x;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 如果有间断，需要重新计算连续情况。
|
|
|
bOKNum = 0;
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, cv::Point(x, y), 1, cv::Scalar(0, 255, 0));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (bSucc)
|
|
|
{
|
|
|
cv::Point p(cur_x, cur_y);
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::circle(showimg, p, 3, cv::Scalar(255, 0, 0));
|
|
|
}
|
|
|
pointList.push_back(p);
|
|
|
if (pointList.size() > 5)
|
|
|
{
|
|
|
// printf("=============feeeee\n");
|
|
|
sx = succ_x - 100;
|
|
|
ex = succ_x + 100;
|
|
|
if (sx < 0)
|
|
|
{
|
|
|
sx = 0;
|
|
|
}
|
|
|
if (ex >= img.cols)
|
|
|
{
|
|
|
ex = img.cols - 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (bdbuge)
|
|
|
{
|
|
|
cv::imwrite(pEdge_Search_Config->strchannel + "show.png", showimg);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
const int maxDeviation = 10; // 可调阈值：最大允许偏离像素
|
|
|
|
|
|
std::vector<cv::Point> avgPoints;
|
|
|
|
|
|
int PNum = pointList.size();
|
|
|
// 第一次计算粗略均值
|
|
|
int sum_y = 0, sum_x = 0;
|
|
|
for (const auto &pt : pointList)
|
|
|
{
|
|
|
|
|
|
sum_x += pt.x;
|
|
|
sum_y += pt.y;
|
|
|
}
|
|
|
float avg_y = sum_y * 1.0f / PNum;
|
|
|
float avg_x = sum_x * 1.0f / PNum;
|
|
|
|
|
|
// 过滤异常点
|
|
|
std::vector<cv::Point> filtered;
|
|
|
for (const auto &pt : pointList)
|
|
|
{
|
|
|
if (search_UP_DOWN) // 横向：判断 y 偏差
|
|
|
{
|
|
|
|
|
|
if (std::abs(pt.y - avg_y) <= maxDeviation)
|
|
|
filtered.push_back(pt);
|
|
|
}
|
|
|
else // 纵向：判断 x 偏差
|
|
|
{
|
|
|
if (std::abs(pt.x - avg_x) <= maxDeviation)
|
|
|
filtered.push_back(pt);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (filtered.empty())
|
|
|
return -1;
|
|
|
|
|
|
int sum_fx = 0, sum_fy = 0;
|
|
|
for (const auto &pt : filtered)
|
|
|
{
|
|
|
sum_fx += pt.x;
|
|
|
sum_fy += pt.y;
|
|
|
}
|
|
|
|
|
|
if (search_UP_DOWN) // 横向：判断 y 偏差
|
|
|
{
|
|
|
outP = sum_fy / (int)filtered.size();
|
|
|
}
|
|
|
else // 纵向：判断 x 偏差
|
|
|
{
|
|
|
outP = sum_fx / (int)filtered.size();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CameraCheckAnalysisy::GetLine(const cv::Mat &img, std::vector<cv::Point> &pointList, int lineNum, int xory, int &outP)
|
|
|
{
|
|
|
|
|
|
if (pointList.size() < 0)
|
|
|
return -1;
|
|
|
|
|
|
const int maxDeviation = 10; // 可调阈值：最大允许偏离像素
|
|
|
|
|
|
std::vector<cv::Point> avgPoints;
|
|
|
|
|
|
int PNum = pointList.size();
|
|
|
// 第一次计算粗略均值
|
|
|
int sum_y = 0, sum_x = 0;
|
|
|
for (const auto &pt : pointList)
|
|
|
{
|
|
|
|
|
|
sum_x += pt.x;
|
|
|
sum_y += pt.y;
|
|
|
}
|
|
|
float avg_y = sum_y * 1.0f / PNum;
|
|
|
float avg_x = sum_x * 1.0f / PNum;
|
|
|
|
|
|
// 过滤异常点
|
|
|
std::vector<cv::Point> filtered;
|
|
|
for (const auto &pt : pointList)
|
|
|
{
|
|
|
if (xory == 0) // 横向：判断 y 偏差
|
|
|
{
|
|
|
if (std::abs(pt.y - avg_y) <= maxDeviation)
|
|
|
filtered.push_back(pt);
|
|
|
}
|
|
|
else // 纵向：判断 x 偏差
|
|
|
{
|
|
|
if (std::abs(pt.x - avg_x) <= maxDeviation)
|
|
|
filtered.push_back(pt);
|
|
|
}
|
|
|
}
|
|
|
if (filtered.empty())
|
|
|
return -1;
|
|
|
|
|
|
int sum_fx = 0, sum_fy = 0;
|
|
|
for (const auto &pt : filtered)
|
|
|
{
|
|
|
sum_fx += pt.x;
|
|
|
sum_fy += pt.y;
|
|
|
}
|
|
|
|
|
|
if (xory == 0) // 横向：判断 y 偏差
|
|
|
{
|
|
|
outP = sum_fy / (int)filtered.size();
|
|
|
}
|
|
|
else // 纵向：判断 x 偏差
|
|
|
{
|
|
|
outP = sum_fx / (int)filtered.size();
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
