|
|
|
|
|
|
|
|
#ifndef _ImageDetConfig_HPP_
|
|
|
#define _ImageDetConfig_HPP_
|
|
|
|
|
|
#include <string>
|
|
|
#include <opencv2/opencv.hpp>
|
|
|
#include "ImgCheckConfig.h"
|
|
|
#include "CheckErrorCodeDefine.hpp"
|
|
|
#include "DetLog.h"
|
|
|
|
|
|
class QX_Merge_Analysis;
|
|
|
#define QX_SAMLLIMG_WIDTH 160
|
|
|
#define QX_SAMLLIMG_HEIGHT 160
|
|
|
|
|
|
enum QX_Stauts
|
|
|
{
|
|
|
QX_Stauts_Analysis,
|
|
|
QX_Stauts_OK,
|
|
|
QX_Stauts_YS,
|
|
|
QX_Stauts_Draw,
|
|
|
};
|
|
|
// 缺陷结果信息
|
|
|
struct QX_ERROR_INFO_
|
|
|
{
|
|
|
|
|
|
int Idx;
|
|
|
int result;
|
|
|
std::string result_name;
|
|
|
cv::Rect roi;
|
|
|
int area;
|
|
|
int energy;
|
|
|
float JudgArea;
|
|
|
float JudgArea_second;
|
|
|
float flen;
|
|
|
int nconfig_qx_type;
|
|
|
std::string qx_name;
|
|
|
int maxValue;
|
|
|
int whiteOrBlack;
|
|
|
float grayDis;
|
|
|
float fUpIou;
|
|
|
float density; // Blob- 密度
|
|
|
std::vector<std::string> detLogList; // 检测日志
|
|
|
std::shared_ptr<DetLog> detlog;
|
|
|
std::vector<int> detRegionidxList; // 对应检测区域的 idx.
|
|
|
|
|
|
QX_Stauts qx_status;
|
|
|
QX_ERROR_INFO_()
|
|
|
{
|
|
|
Init();
|
|
|
}
|
|
|
~QX_ERROR_INFO_()
|
|
|
{
|
|
|
}
|
|
|
void Init()
|
|
|
{
|
|
|
whiteOrBlack = 0;
|
|
|
Idx = 0;
|
|
|
area = 0;
|
|
|
energy = 0;
|
|
|
JudgArea = 0;
|
|
|
JudgArea_second = 0;
|
|
|
flen = 0;
|
|
|
nconfig_qx_type = 0;
|
|
|
qx_name = "";
|
|
|
maxValue = 0;
|
|
|
grayDis = 0;
|
|
|
fUpIou = 0;
|
|
|
result = 0;
|
|
|
result_name = "OK";
|
|
|
density = 0;
|
|
|
cv::Rect roi = cv::Rect(0, 0, 0, 0);
|
|
|
detLogList.erase(detLogList.begin(), detLogList.end());
|
|
|
detLogList.clear();
|
|
|
detRegionidxList.clear();
|
|
|
detlog = std::make_shared<DetLog>();
|
|
|
qx_status = QX_Stauts_Analysis;
|
|
|
}
|
|
|
void print(std::string str = "")
|
|
|
{
|
|
|
std::cout << str << ": "
|
|
|
<< "Idx: " << Idx
|
|
|
<< ", Result: " << result << " " << result_name
|
|
|
<< ", ROI: (" << roi.x << ", " << roi.y << ", " << roi.width << ", " << roi.height << ")"
|
|
|
<< ", Area: " << area
|
|
|
<< ", Energy: " << energy
|
|
|
<< ", JudgArea: " << JudgArea
|
|
|
<< ", JudgArea second: " << JudgArea_second
|
|
|
<< ", density: " << density
|
|
|
<< ", Flen: " << flen
|
|
|
<< ", nconfig_qx_type: " << nconfig_qx_type
|
|
|
<< ", QX Name: " << qx_name
|
|
|
<< ", Max Value: " << maxValue
|
|
|
<< ", Gray Dis: " << grayDis
|
|
|
<< ", fUpIou: " << fUpIou
|
|
|
<< ", whiteOrBlack: " << whiteOrBlack
|
|
|
<< std::endl;
|
|
|
}
|
|
|
};
|
|
|
struct One_Image_CheckResult_
|
|
|
{
|
|
|
|
|
|
cv::Rect CutRoi; // 当前检测图片 对应的裁切区域
|
|
|
cv::Rect Param_CropRoi; // 参数模版 对应的裁切区域
|
|
|
std::shared_ptr<std::vector<QX_ERROR_INFO_>> pQx_ErrorList; // 缺陷错误信息
|
|
|
|
|
|
void print(std::string str = "")
|
|
|
{
|
|
|
std::cout << str << ": "
|
|
|
<< " CutRoi: (" << CutRoi.x << ", " << CutRoi.y << ", " << CutRoi.width << ", " << CutRoi.height << ")"
|
|
|
<< std::endl;
|
|
|
|
|
|
std::cout << str << ": "
|
|
|
<< " Param_CropRoi: (" << Param_CropRoi.x << ", " << Param_CropRoi.y << ", " << Param_CropRoi.width << ", " << Param_CropRoi.height << ")"
|
|
|
<< std::endl;
|
|
|
|
|
|
for (int i = 0; i < pQx_ErrorList->size(); i++)
|
|
|
{
|
|
|
pQx_ErrorList->at(i).print(std::to_string(i));
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
// 定位结果
|
|
|
struct Align_Result
|
|
|
{
|
|
|
bool bDet; // 检测状态 true 成功，false 失败。
|
|
|
bool bUse; // 是否要使用。
|
|
|
bool bDraw; // 是否绘制
|
|
|
|
|
|
cv::Point bestMatch;
|
|
|
int offt_x; // 偏移值
|
|
|
int offt_y; // 偏移值
|
|
|
float fCropROI_Scale_ParmToDet_X; // 裁剪区域的缩放
|
|
|
float fCropROI_Scale_ParmToDet_Y; // 裁剪区域的缩放
|
|
|
|
|
|
std::vector<cv::Point> feature_PointList_DetImg; // 特征区域点 检查图上的特征点
|
|
|
cv::Rect Crop_Roi_DetImg; // 检测图片上的 裁切区域
|
|
|
cv::Rect Crop_Roi_ParmImg; // 参数图片上的 裁切区域
|
|
|
|
|
|
Align_Result()
|
|
|
{
|
|
|
Init();
|
|
|
}
|
|
|
void Init()
|
|
|
{
|
|
|
bDet = false;
|
|
|
bUse = false;
|
|
|
offt_x = 0;
|
|
|
offt_y = 0;
|
|
|
bestMatch = cv::Point(0, 0);
|
|
|
fCropROI_Scale_ParmToDet_X = 1;
|
|
|
fCropROI_Scale_ParmToDet_Y = 1;
|
|
|
feature_PointList_DetImg.clear();
|
|
|
Crop_Roi_DetImg = cv::Rect(0, 0, 0, 0);
|
|
|
Crop_Roi_ParmImg = cv::Rect(0, 0, 0, 0);
|
|
|
bDraw = false;
|
|
|
}
|
|
|
void copy(Align_Result tem)
|
|
|
{
|
|
|
this->bDet = tem.bDet;
|
|
|
this->bUse = tem.bUse;
|
|
|
this->offt_x = tem.offt_x;
|
|
|
this->offt_y = tem.offt_y;
|
|
|
this->fCropROI_Scale_ParmToDet_X = tem.fCropROI_Scale_ParmToDet_X;
|
|
|
this->fCropROI_Scale_ParmToDet_Y = tem.fCropROI_Scale_ParmToDet_Y;
|
|
|
this->bDraw = tem.bDraw;
|
|
|
this->bestMatch = tem.bestMatch;
|
|
|
this->Crop_Roi_DetImg = tem.Crop_Roi_DetImg;
|
|
|
this->Crop_Roi_ParmImg = tem.Crop_Roi_ParmImg;
|
|
|
this->feature_PointList_DetImg.assign(tem.feature_PointList_DetImg.begin(), tem.feature_PointList_DetImg.end());
|
|
|
}
|
|
|
// 从检测图的原始图片 映射到 参数的原始图
|
|
|
cv::Point Det_srcToParm_src_Point(cv::Point &p)
|
|
|
{
|
|
|
cv::Point dst_p;
|
|
|
dst_p.x = (p.x - offt_x) / fCropROI_Scale_ParmToDet_X;
|
|
|
dst_p.y = (p.y - offt_y) / fCropROI_Scale_ParmToDet_Y;
|
|
|
return dst_p;
|
|
|
}
|
|
|
cv::Rect Det_srcToParm_src_Rect(cv::Rect &roi)
|
|
|
{
|
|
|
cv::Rect dst_roi;
|
|
|
cv::Point src_pl = cv::Point(roi.x, roi.y);
|
|
|
cv::Point src_rb = cv::Point(roi.x + roi.width, roi.y + roi.height);
|
|
|
cv::Point p_lt = Det_srcToParm_src_Point(src_pl);
|
|
|
cv::Point p_rb = Det_srcToParm_src_Point(src_rb);
|
|
|
dst_roi.x = p_lt.x;
|
|
|
dst_roi.y = p_lt.y;
|
|
|
dst_roi.width = p_rb.x - p_lt.x;
|
|
|
dst_roi.height = p_rb.y - p_lt.y;
|
|
|
|
|
|
return dst_roi;
|
|
|
}
|
|
|
// 参数的原始图 映射到 检测图的原始图片
|
|
|
cv::Point Parm_srcToDet_src_Point(cv::Point &p)
|
|
|
{
|
|
|
cv::Point dst_p;
|
|
|
dst_p.x = p.x * fCropROI_Scale_ParmToDet_X + offt_x;
|
|
|
dst_p.y = p.y * fCropROI_Scale_ParmToDet_Y + offt_y;
|
|
|
return dst_p;
|
|
|
}
|
|
|
cv::Rect Parm_srcToDet_src_Rect(cv::Rect &roi)
|
|
|
{
|
|
|
cv::Rect dst_roi;
|
|
|
cv::Point src_pl = cv::Point(roi.x, roi.y);
|
|
|
cv::Point src_rb = cv::Point(roi.x + roi.width, roi.y + roi.height);
|
|
|
cv::Point p_lt = Parm_srcToDet_src_Point(src_pl);
|
|
|
cv::Point p_rb = Parm_srcToDet_src_Point(src_rb);
|
|
|
dst_roi.x = p_lt.x;
|
|
|
dst_roi.y = p_lt.y;
|
|
|
dst_roi.width = p_rb.x - p_lt.x;
|
|
|
dst_roi.height = p_rb.y - p_lt.y;
|
|
|
|
|
|
return dst_roi;
|
|
|
}
|
|
|
// 参数图片上的点 对应到 检测裁切后上的点
|
|
|
cv::Point Parm_srcToDet_Crop_Point(cv::Point &p)
|
|
|
{
|
|
|
cv::Point dst_p = Parm_srcToDet_src_Point(p);
|
|
|
dst_p.x -= Crop_Roi_DetImg.x;
|
|
|
dst_p.y -= Crop_Roi_DetImg.y;
|
|
|
return dst_p;
|
|
|
}
|
|
|
// 参数图片上的点 对应到 检测裁切后上的点
|
|
|
cv::Rect Parm_srcToDet_Crop_Rect(cv::Rect &roi)
|
|
|
{
|
|
|
cv::Rect dst_roi;
|
|
|
cv::Point src_pl = cv::Point(roi.x, roi.y);
|
|
|
cv::Point src_rb = cv::Point(roi.x + roi.width, roi.y + roi.height);
|
|
|
cv::Point p_lt = Parm_srcToDet_Crop_Point(src_pl);
|
|
|
cv::Point p_rb = Parm_srcToDet_Crop_Point(src_rb);
|
|
|
dst_roi.x = p_lt.x;
|
|
|
dst_roi.y = p_lt.y;
|
|
|
dst_roi.width = p_rb.x - p_lt.x;
|
|
|
dst_roi.height = p_rb.y - p_lt.y;
|
|
|
|
|
|
return dst_roi;
|
|
|
}
|
|
|
void CalOfftScal()
|
|
|
{
|
|
|
cv::Point src_pl = cv::Point(Crop_Roi_DetImg.x, Crop_Roi_DetImg.y);
|
|
|
cv::Point src_rb = cv::Point(Crop_Roi_DetImg.x + Crop_Roi_DetImg.width, Crop_Roi_DetImg.y + Crop_Roi_DetImg.height);
|
|
|
|
|
|
cv::Point param_pl = cv::Point(Crop_Roi_ParmImg.x, Crop_Roi_ParmImg.y);
|
|
|
cv::Point param_rb = cv::Point(Crop_Roi_ParmImg.x + Crop_Roi_ParmImg.width, Crop_Roi_ParmImg.y + Crop_Roi_ParmImg.height);
|
|
|
|
|
|
int a_x_1 = src_pl.x;
|
|
|
int a_x_2 = src_rb.x;
|
|
|
|
|
|
int b_x_1 = param_pl.x;
|
|
|
int b_x_2 = param_rb.x;
|
|
|
|
|
|
int diff_a_x = a_x_1 - a_x_2;
|
|
|
int diff_b_x = b_x_1 - b_x_2;
|
|
|
float fscale_x = 1;
|
|
|
if (diff_b_x != 0)
|
|
|
{
|
|
|
fscale_x = diff_a_x * 1.0f / diff_b_x;
|
|
|
}
|
|
|
int ofx = a_x_1 - fscale_x * b_x_1;
|
|
|
|
|
|
// printf("a_x_1 %d a_x_2 %d\n", a_x_1, a_x_2);
|
|
|
// printf("b_x_1 %d b_x_2 %d\n", b_x_1, b_x_2);
|
|
|
// printf("fscale_x %f ofx %d \n", fscale_x, ofx);
|
|
|
|
|
|
int a_y_1 = src_pl.y;
|
|
|
int a_y_2 = src_rb.y;
|
|
|
|
|
|
int b_y_1 = param_pl.y;
|
|
|
int b_y_2 = param_rb.y;
|
|
|
|
|
|
int diff_a_y = a_y_1 - a_y_2;
|
|
|
int diff_b_y = b_y_1 - b_y_2;
|
|
|
float fscale_y = 1;
|
|
|
if (diff_b_y != 0)
|
|
|
{
|
|
|
fscale_y = diff_a_y * 1.0f / diff_b_y;
|
|
|
}
|
|
|
int ofy = a_y_1 - fscale_y * b_y_1;
|
|
|
|
|
|
// printf("a_y_1 %d a_y_2 %d\n", a_y_1, a_y_2);
|
|
|
// printf("b_y_1 %d b_y_2 %d\n", b_y_1, b_y_2);
|
|
|
// printf("fscale_y %f ofy %d \n", fscale_y, ofy);
|
|
|
|
|
|
offt_x = ofx;
|
|
|
offt_y = ofy;
|
|
|
fCropROI_Scale_ParmToDet_X = fscale_x;
|
|
|
fCropROI_Scale_ParmToDet_Y = fscale_y;
|
|
|
}
|
|
|
void print()
|
|
|
{
|
|
|
printf("scale x %f y %f ,offt x %d y %d\n", fCropROI_Scale_ParmToDet_X, fCropROI_Scale_ParmToDet_Y, offt_x, offt_y);
|
|
|
}
|
|
|
};
|
|
|
// 边缘检测结果
|
|
|
struct EdgeDetResult
|
|
|
{
|
|
|
int nresult;
|
|
|
cv::Rect cutRoi;
|
|
|
cv::Mat shieldMask; // 在 屏蔽mask图片
|
|
|
cv::Mat shieldMask_Src; // 在原图上的屏蔽mask图片
|
|
|
cv::Mat edge_cutMask; // 边缘 图片 在裁切后的图片
|
|
|
std::shared_ptr<std::vector<cv::Rect>> pEdgeDet_roiList; // 边缘检测的区域
|
|
|
Align_Result m_align_Result;
|
|
|
|
|
|
int ninstruct;
|
|
|
EdgeDetResult()
|
|
|
{
|
|
|
nresult = -1;
|
|
|
cutRoi = cv::Rect(0, 0, 0, 0);
|
|
|
m_align_Result.Init();
|
|
|
ninstruct = 0;
|
|
|
pEdgeDet_roiList = std::make_shared<std::vector<cv::Rect>>();
|
|
|
}
|
|
|
};
|
|
|
// 产品相关的 基础检测结果
|
|
|
struct ProductBaseResult
|
|
|
{
|
|
|
std::string strproductName = ""; // 产品 ID
|
|
|
int nCamera_Num = 0;
|
|
|
std::shared_ptr<DetLog> detlog;
|
|
|
std::shared_ptr<QX_Merge_Analysis> pQX_Merge_Analysis;
|
|
|
// ProductBaseResult()
|
|
|
// {
|
|
|
// pQX_Merge_Analysis = QX_Merge_Analysis::GetInstance();
|
|
|
// pQX_Merge_Analysis->InitData();
|
|
|
// }
|
|
|
};
|
|
|
// 相机相关的 基础检测结果
|
|
|
struct MakeLine_Result
|
|
|
{
|
|
|
int nresult = 1;
|
|
|
cv::Rect markLine_Roi_X = cv::Rect(0, 0, 0, 0);
|
|
|
cv::Rect markLine_Roi_Y = cv::Rect(0, 0, 0, 0);
|
|
|
};
|
|
|
struct ZF_Result
|
|
|
{
|
|
|
int nresult = 1;
|
|
|
bool bShield_ZF = false; // 是否屏蔽字符
|
|
|
std::vector<cv::Rect> pZF_roiList; // 字符的区域
|
|
|
std::vector<cv::Point> ZF_centerPoint; // 字符的中心点位置
|
|
|
};
|
|
|
struct CameraBaseResult
|
|
|
{
|
|
|
enum ImageDet_Status
|
|
|
{
|
|
|
ImageDet_Status_None = 0,
|
|
|
ImageDet_Status_NoDet = 1,
|
|
|
ImageDet_Status_DetComplete = 2,
|
|
|
};
|
|
|
std::string strCameraName = ""; // 相机结果 ID
|
|
|
std::shared_ptr<EdgeDetResult> pEdgeDetResult; // 边缘检测结果
|
|
|
std::shared_ptr<MakeLine_Result> pMarkLineResult; // MarkLine检测结果
|
|
|
std::shared_ptr<ZF_Result> pZF_Result; // zf 检测结果
|
|
|
|
|
|
ImageDet_Status UpImg_Status = ImageDet_Status_None; // Up 画面
|
|
|
ImageDet_Status DPImg_Status = ImageDet_Status_None; // DP 画面
|
|
|
|
|
|
cv::Mat DP_MaskImg; // DP 画面 mask图片
|
|
|
cv::Mat UP_MaskImg; // UP 画面 mask图片
|
|
|
};
|
|
|
struct ImageDetconfig
|
|
|
{
|
|
|
cv::Mat ShieldMaskImg; // 屏蔽mask
|
|
|
cv::Mat UpMaskImg; // Up 画面 mask图片
|
|
|
cv::Mat DPMaskImg;
|
|
|
cv::Mat edge_maskImg;
|
|
|
bool bUseUpMaskImg;
|
|
|
std::shared_ptr<std::vector<cv::Rect>> pZF_roiList; // 字符的区域
|
|
|
|
|
|
std::shared_ptr<shareImage> pBaseImgCheckConfig;
|
|
|
Align_Result alignResult; // 定位结果
|
|
|
ImageDetconfig()
|
|
|
{
|
|
|
Init();
|
|
|
}
|
|
|
~ImageDetconfig()
|
|
|
{
|
|
|
}
|
|
|
void Init()
|
|
|
{
|
|
|
bUseUpMaskImg = false;
|
|
|
if (!ShieldMaskImg.empty())
|
|
|
{
|
|
|
ShieldMaskImg.release();
|
|
|
}
|
|
|
if (!UpMaskImg.empty())
|
|
|
{
|
|
|
UpMaskImg.release();
|
|
|
}
|
|
|
if (!DPMaskImg.empty())
|
|
|
{
|
|
|
DPMaskImg.release();
|
|
|
}
|
|
|
if (!edge_maskImg.empty())
|
|
|
{
|
|
|
edge_maskImg.release();
|
|
|
}
|
|
|
alignResult.Init();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
struct ImageDetResult
|
|
|
{
|
|
|
bool bShield_ZF; // 是否要屏蔽字符区域
|
|
|
bool bUseUpImg; // 是否要使用 up img 进行过滤
|
|
|
cv::Mat AI_maskImg;
|
|
|
int Yx_result; // 异显检测状态
|
|
|
float fUP_IOU; // UP 画面 使用的 iou
|
|
|
std::shared_ptr<std::vector<cv::Rect>> pZF_roiList; // 字符的区域
|
|
|
std::shared_ptr<One_Image_CheckResult_> pOneImgDetResult; // 单图检测结果
|
|
|
std::shared_ptr<CheckResult> pBaseImgCheckResult;
|
|
|
ImageDetResult()
|
|
|
{
|
|
|
Init();
|
|
|
}
|
|
|
~ImageDetResult()
|
|
|
{
|
|
|
}
|
|
|
void Init()
|
|
|
{
|
|
|
bShield_ZF = false;
|
|
|
if (!AI_maskImg.empty())
|
|
|
{
|
|
|
AI_maskImg.release();
|
|
|
}
|
|
|
Yx_result = 0;
|
|
|
fUP_IOU = 0;
|
|
|
bUseUpImg = false;
|
|
|
}
|
|
|
};
|
|
|
#endif //_CORELOGICFACTORY_HPP_
|
