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

update 更新参数配置

Browse Source
dev_lsy
liusiyang 2 weeks ago
parent d0af74cf4e
commit 384fc6dd24
3 changed files with 62 additions and 287 deletions
Show Stats Download Patch File Download Diff File

36
AlgorithmModule/src/ImgCheckAnalysisy.cpp
Unescape View File

@ -1785,42 +1785,6 @@ int ImgCheckAnalysisy::DrawResult_Step_1()
cv::polylines(m_CheckResult_shareP->resultimg, draw_pts, true, cv::Scalar(255, 0, 0), 1); cv::polylines(m_CheckResult_shareP->resultimg, draw_pts, true, cv::Scalar(255, 0, 0), 1);
} }
if (m_pbaseCheckFunction && m_pbaseCheckFunction->markLine.region.size() > 1)
{
std::vector<cv::Point> product_roi_show;
for (const auto &pt : m_pbaseCheckFunction->markLine.region)
{
cv::Point draw_pt;
draw_pt.x = (pt.x - m_Crop_Roi_paramImg.x) * fs_resize_x;
draw_pt.y = (pt.y - m_Crop_Roi_paramImg.y) * fs_resize_y;
product_roi_show.push_back(draw_pt);
}
cv::polylines(
m_CheckResult_shareP->resultimg,
product_roi_show,
true,
cv::Scalar(0, 255, 0),
1);
}
if (m_pEdge_Align_Result.get() != NULL)
{
if (m_pbaseCheckFunction->markLine.bDraw)
{
for (size_t i = 0; i < m_pEdge_Align_Result->markresulList.size(); i++)
{
// if (m_pEdge_Align_Result->markresulList[i].status == Mark_Result_Status_OK)
{
cv::Point p;
p.x = m_pEdge_Align_Result->markresulList[i].det_Local_DetImg.x * fs_resize_x;
p.y = m_pEdge_Align_Result->markresulList[i].det_Local_DetImg.y * fs_resize_y;
cv::circle(m_CheckResult_shareP->resultimg, p, 5, cv::Scalar(0, 255, 0));
}
}
}
}
// cv::imwrite("sss.png", m_CheckResult_shareP->resultimg); // cv::imwrite("sss.png", m_CheckResult_shareP->resultimg);
return 0; return 0;
} }

140
ConfigModule/include/CheckConfigDefine.h
Unescape View File

@ -1018,52 +1018,44 @@ struct ChannelCheckFunction
}; };
// 基础检测功能 mark // 基础检测功能 mark
struct Base_Function_MarkLine struct Base_Function_ALign
{ {
bool bOpen; // 是否开启 bool bOpen; // 是否开启
bool bDraw; // 是否绘制 float angle_diff;
bool badapt_region; // 是否自适应区域 float x_offset;
cv::Rect productROI; float y_offset;
std::vector<cv::Point> region;
cv::Point mark_local_1;
cv::Point mark_local_2;
Base_Function_MarkLine()
Base_Function_ALign()
{ {
Init(); Init();
} }
void Init() void Init()
{ {
bOpen = false; bOpen = false;
bDraw = false; angle_diff = 0.0;
badapt_region = false; x_offset = 0.0;
mark_local_1 = cv::Point(0, 0); y_offset = 0.0;
mark_local_2 = cv::Point(0, 0);
productROI = cv::Rect(0, 0, 0, 0);
region.clear();
} }
void copy(Base_Function_MarkLine tem) void copy(Base_Function_ALign tem)
{ {
this->bOpen = tem.bOpen; this->bOpen = tem.bOpen;
this->region.assign(tem.region.begin(), tem.region.end()); this->angle_diff = tem.angle_diff;
this->productROI = tem.productROI; this->x_offset = tem.x_offset;
this->bDraw = tem.bDraw; this->y_offset = tem.y_offset;
this->badapt_region = tem.badapt_region;
this->mark_local_1 = tem.mark_local_1;
this->mark_local_2 = tem.mark_local_2;
} }
void print(std::string str) void print(std::string str)
{ {
printf("%s>>bOpen %d bDraw %d badapt_region %d mark1 [%d %d] mark2 [%d %d] \n", str.c_str(), printf("%s>>bOpen %d angle_diff %f x_offset %f y_offset %f \n", str.c_str(),
bOpen, bDraw, badapt_region,mark_local_1.x, mark_local_1.y, mark_local_2.x, mark_local_2.y); bOpen, angle_diff, x_offset, y_offset);
} }
std::string GetInfo(std::string str) std::string GetInfo(std::string str)
{ {
char buffer[256]; char buffer[256];
sprintf(buffer, "%s>>bOpen %d bDraw %d badapt_region %d mark1 [%d %d] mark2 [%d %d] \n", str.c_str(), sprintf(buffer, "%s>>bOpen %d angle_diff %f x_offset %f y_offset %f \n", str.c_str(),
bOpen, bDraw, badapt_region,mark_local_1.x, mark_local_1.y, mark_local_2.x, mark_local_2.y); bOpen, angle_diff, x_offset, y_offset);
std::string str123 = buffer; std::string str123 = buffer;
return str123; return str123;
} }
@ -1206,91 +1198,43 @@ struct Base_Function_BigNG
} }
}; };
// 基础检测功能 CELL AOI 边缘缺陷检测 // 基础检测功能 CELL AOI 边缘缺陷检测
struct Base_Function_Edge_Det struct Base_Function_Pin_Det
{ {
bool bOpen; // 是否开启 bool bOpen; // 是否开启
int Search_threshold; // 搜索边缘阈值 float pin_x_offset; // pin x 偏移
int Det_threshold; // 缺陷检测阈值 float pin_y_offset; // pin y 偏移
int Det_Range; // 检测范围
int QX_Widht_min; // 缺陷宽度-最小 bool bDrawResult; // 是否绘制结果
int QX_Widht_max; Base_Function_Pin_Det()
int QX_Height_min;
int QX_Height_max;
bool queJiao_LU_Open;
bool queJiao_RU_Open;
bool queJiao_LD_Open;
bool queJiao_RD_Open;
int queJiao_width;
int queJiao_height;
bool bDrawRoi;
cv::Rect draw_ROI;
std::vector<cv::Point> region;
bool bDrawResult; // 是否绘制结果
Base_Function_Edge_Det()
{ {
Init(); Init();
} }
void Init() void Init()
{ {
bOpen = false; bOpen = false;
Search_threshold = 30; pin_x_offset = 0;
Det_threshold = 30; pin_y_offset = 0;
Det_Range = 100;
QX_Widht_min = 10;
QX_Widht_max = 100;
QX_Height_min = 10;
QX_Height_max = 100;
queJiao_LU_Open = false;
queJiao_RU_Open = false;
queJiao_LD_Open = false;
queJiao_RD_Open = false;
queJiao_width = 50;
queJiao_height = 50;
bDrawRoi = false;
draw_ROI = cv::Rect(0, 0, 0, 0);
region.clear();
region.erase(region.begin(), region.end());
bDrawResult = false; bDrawResult = false;
} }
void copy(Base_Function_Edge_Det tem) void copy(Base_Function_Pin_Det tem)
{ {
this->bOpen = tem.bOpen; this->bOpen = tem.bOpen;
this->Search_threshold = tem.Search_threshold; this->pin_x_offset = tem.pin_x_offset;
this->Det_threshold = tem.Det_threshold; this->pin_y_offset = tem.pin_y_offset;
this->Det_Range = tem.Det_Range;
this->QX_Widht_min = tem.QX_Widht_min;
this->QX_Widht_max = tem.QX_Widht_max;
this->QX_Height_min = tem.QX_Height_min;
this->QX_Height_max = tem.QX_Height_max;
this->queJiao_LU_Open = tem.queJiao_LU_Open;
this->queJiao_RU_Open = tem.queJiao_RU_Open;
this->queJiao_LD_Open = tem.queJiao_LD_Open;
this->queJiao_RD_Open = tem.queJiao_RD_Open;
this->queJiao_width = tem.queJiao_width;
this->queJiao_height = tem.queJiao_height;
this->region.assign(tem.region.begin(), tem.region.end());
this->draw_ROI = tem.draw_ROI;
this->bDrawRoi = tem.bDrawRoi;
this->bDrawResult = tem.bDrawResult; this->bDrawResult = tem.bDrawResult;
} }
void print(std::string str) void print(std::string str)
{ {
printf("%s>>bOpen %d Search_threshold %d Det_threshold %d Det_Range %d QX_Widht [%d %d] QX_Height [%d %d]\n", str.c_str(), printf("%s>>bOpen %d pin_x_offset %f pin_y_offset %f bDrawResult %d\n", str.c_str(),
bOpen, Search_threshold, Det_threshold, Det_Range, QX_Widht_min, QX_Widht_max, QX_Height_min, QX_Height_max); bOpen, pin_x_offset, pin_y_offset, bDrawResult);
} }
std::string GetInfo(std::string str) std::string GetInfo(std::string str)
{ {
char buffer[256]; char buffer[256];
sprintf(buffer, "%s>>bOpen %d Search_threshold %d Det_threshold %d Det_Range %d QX_Widht [%d %d] QX_Height [%d %d]\n", str.c_str(), sprintf(buffer, "%s>>bOpen %d pin_x_offset %f pin_y_offset %f bDrawResult %d\n", str.c_str(),
bOpen, Search_threshold, Det_threshold, Det_Range, QX_Widht_min, QX_Widht_max, QX_Height_min, QX_Height_max); bOpen, pin_x_offset, pin_y_offset, bDrawResult);
std::string str123 = buffer; std::string str123 = buffer;
return str123; return str123;
} }
@ -1298,8 +1242,8 @@ struct Base_Function_Edge_Det
// 基础检测功能 // 基础检测功能
struct BaseCheckFunction struct BaseCheckFunction
{ {
Base_Function_MarkLine markLine; Base_Function_ALign ALign_Config;
Base_Function_Edge_Det edgeDet; Base_Function_Pin_Det pinDet;
Base_Function_SaveImg saveImg; Base_Function_SaveImg saveImg;
Base_Function_BigNG bigNG; Base_Function_BigNG bigNG;
BaseCheckFunction() BaseCheckFunction()
@ -1308,31 +1252,31 @@ struct BaseCheckFunction
} }
void Init() void Init()
{ {
markLine.Init(); ALign_Config.Init();
edgeDet.Init(); pinDet.Init();
saveImg.Init(); saveImg.Init();
bigNG.Init(); bigNG.Init();
} }
void copy(BaseCheckFunction tem) void copy(BaseCheckFunction tem)
{ {
this->markLine.copy(tem.markLine); this->ALign_Config.copy(tem.ALign_Config);
this->edgeDet.copy(tem.edgeDet); this->pinDet.copy(tem.pinDet);
this->saveImg.copy(tem.saveImg); this->saveImg.copy(tem.saveImg);
this->bigNG.copy(tem.bigNG); this->bigNG.copy(tem.bigNG);
} }
void print(std::string str) void print(std::string str)
{ {
printf("******* %s *********\n", str.c_str()); printf("******* %s *********\n", str.c_str());
markLine.print("markLine"); ALign_Config.print("ALign_Config");
edgeDet.print("edgeDet"); pinDet.print("pinDet");
saveImg.print("saveImg"); saveImg.print("saveImg");
bigNG.print("bigNG"); bigNG.print("bigNG");
} }
std::string GetInfo(std::string str) std::string GetInfo(std::string str)
{ {
std::string str123 = ""; std::string str123 = "";
str123 += markLine.GetInfo("markLine"); str123 += ALign_Config.GetInfo("ALign_Config");
str123 += edgeDet.GetInfo("edgeDet"); str123 += pinDet.GetInfo("pinDet");
str123 += saveImg.GetInfo("saveImg"); str123 += saveImg.GetInfo("saveImg");
str123 += bigNG.GetInfo("bigNG"); str123 += bigNG.GetInfo("bigNG");
// str123 += "\n"; // str123 += "\n";

173
ConfigModule/src/JsonConfig.cpp
Unescape View File

@ -775,78 +775,25 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
auto value_f = value; auto value_f = value;
// std::cout << value_f << std::endl; // std::cout << value_f << std::endl;
// getchar(); // getchar();
_config.markLine.bOpen = value_f["isOpen"].asBool(); _config.ALign_Config.bOpen = value_f["isOpen"].asBool();
if (_config.markLine.bOpen) if (_config.ALign_Config.bOpen)
{ {
if (value_f["form"]["ALign_Config"]["angle_diff"])
{ {
auto crop_roi = value_f["form"]["ALign_Config"]["Product_ROI"]; _config.ALign_Config.angle_diff = value_f["form"]["ALign_Config"]["angle_diff"].asFloat();
// 2、读取区域点
{
auto value_region = value_f["form"]["ALign_Config"]["Product_ROI"];
if (value_region.isArray())
{
for (int idx = 0; idx < value_region.size(); idx++)
{
cv::Point p;
p.x = value_region[idx][0].asInt();
p.y = value_region[idx][1].asInt();
_config.markLine.region.emplace_back(p);
}
if (_config.markLine.region.size() > 0)
{
_config.markLine.productROI = boundingRect(_config.markLine.region);
}
}
}
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
}
if (value_f["form"]["ALign_Config"]["bDraw"])
{
_config.markLine.bDraw = value_f["form"]["ALign_Config"]["bDraw"].asBool();
}
if (value_f["form"]["ALign_Config"]["badapt_region"])
{
_config.markLine.badapt_region = value_f["form"]["ALign_Config"]["badapt_region"].asBool();
} }
if (value_f["form"]["ALign_Config"]["x_offset"])
{ {
auto value_circl = value_f["form"]["ALign_Config"]["mark_1_Local"]["path"]; _config.ALign_Config.x_offset = value_f["form"]["ALign_Config"]["x_offset"].asFloat();
if (value_circl.isArray())
{
if (value_circl[0][0])
{
_config.markLine.mark_local_1.x = value_circl[0][0].asInt();
}
if (value_circl[0][1])
{
_config.markLine.mark_local_1.y = value_circl[0][1].asInt();
}
}
} }
if (value_f["form"]["ALign_Config"]["y_offset"])
{ {
auto value_circl = value_f["form"]["ALign_Config"]["mark_2_Local"]["path"]; _config.ALign_Config.y_offset = value_f["form"]["ALign_Config"]["y_offset"].asFloat();
if (value_circl.isArray())
{
if (value_circl[0][0])
{
_config.markLine.mark_local_2.x = value_circl[0][0].asInt();
}
if (value_circl[0][1])
{
_config.markLine.mark_local_2.y = value_circl[0][1].asInt();
}
}
} }
// _config.markLine.print("dfe");
// getchar();
} }
else else
{ {
_config.markLine.Init(); _config.ALign_Config.Init();
} }
} }
if ("Pin_QX_Detect" == strCode) if ("Pin_QX_Detect" == strCode)
@ -854,108 +801,28 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
auto value_f = value; auto value_f = value;
// std::cout << value_f << std::endl; // std::cout << value_f << std::endl;
// getchar(); // getchar();
_config.edgeDet.bOpen = value_f["isOpen"].asBool(); _config.pinDet.bOpen = value_f["isOpen"].asBool();
if (_config.edgeDet.bOpen) if (_config.pinDet.bOpen)
{ {
if (value_f["form"]["Search_Config"]["Search_threshold"]) if (value_f["form"]["Det_Config"]["pin_x_offset"])
{
_config.edgeDet.Search_threshold = value_f["form"]["Search_Config"]["Search_threshold"].asInt();
}
if (value_f["form"]["Detect_Config"]["Det_threshold"])
{
_config.edgeDet.Det_threshold = value_f["form"]["Detect_Config"]["Det_threshold"].asInt();
}
if (value_f["form"]["Detect_Config"]["Det_Range"])
{ {
_config.edgeDet.Det_Range = value_f["form"]["Detect_Config"]["Det_Range"].asInt(); _config.pinDet.pin_x_offset = value_f["form"]["Search_Config"]["pin_x_offset"].asFloat();
} }
if (value_f["form"]["Det_Config"]["pin_y_offset"])
if (value_f["form"]["Detect_Config"]["QX_Widht_min"])
{
_config.edgeDet.QX_Widht_min = value_f["form"]["Detect_Config"]["QX_Widht_min"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Widht_max"])
{ {
_config.edgeDet.QX_Widht_max = value_f["form"]["Detect_Config"]["QX_Widht_max"].asInt(); _config.pinDet.pin_y_offset = value_f["form"]["Detect_Config"]["pin_y_offset"].asFloat();
}
if (value_f["form"]["Detect_Config"]["QX_Height_min"])
{
_config.edgeDet.QX_Height_min = value_f["form"]["Detect_Config"]["QX_Height_min"].asInt();
}
if (value_f["form"]["Detect_Config"]["QX_Height_max"])
{
_config.edgeDet.QX_Height_max = value_f["form"]["Detect_Config"]["QX_Height_max"].asInt();
}
///============================================
if (value_f["form"]["Jiao_Config"]["LU_Jiao"])
{
_config.edgeDet.queJiao_LU_Open = value_f["form"]["Jiao_Config"]["LU_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["RU_Jiao"])
{
_config.edgeDet.queJiao_RU_Open = value_f["form"]["Jiao_Config"]["RU_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["LD_Jiao"])
{
_config.edgeDet.queJiao_LD_Open = value_f["form"]["Jiao_Config"]["LD_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["RD_Jiao"])
{
_config.edgeDet.queJiao_RD_Open = value_f["form"]["Jiao_Config"]["RD_Jiao"].asBool();
}
if (value_f["form"]["Jiao_Config"]["Jiao_Width"])
{
_config.edgeDet.queJiao_width = value_f["form"]["Jiao_Config"]["Jiao_Width"].asInt();
}
if (value_f["form"]["Jiao_Config"]["Jiao_Height"])
{
_config.edgeDet.queJiao_height = value_f["form"]["Jiao_Config"]["Jiao_Height"].asInt();
}
if (value_f["form"]["Draw_Config"]["Open"])
{
_config.edgeDet.bDrawRoi = value_f["form"]["Draw_Config"]["Open"].asBool();
}
// 2、读取区域点
{
auto value_region = value_f["form"]["Draw_Config"]["Edge_ROI"];
if (value_region.isArray())
{
for (int idx = 0; idx < value_region.size(); idx++)
{
cv::Point p;
p.x = value_region[idx][0].asInt();
p.y = value_region[idx][1].asInt();
_config.edgeDet.region.emplace_back(p);
}
if (_config.edgeDet.region.size() > 0)
{
_config.edgeDet.draw_ROI = boundingRect(_config.edgeDet.region);
}
}
} }
if (value_f["form"]["otherConfig"]["bDrawResult"]) if (value_f["form"]["otherConfig"]["bDrawResult"])
{ {
_config.edgeDet.bDrawResult = value_f["form"]["otherConfig"]["bDrawResult"].asBool(); _config.pinDet.bDrawResult = value_f["form"]["otherConfig"]["bDrawResult"].asBool();
} }
} }
else else
{ {
_config.edgeDet.Init(); _config.pinDet.Init();
} }
// _config.edgeDet.print("edgeDet"); // _config.pinDet.print("pinDet");
// getchar(); // getchar();
} }
if ("Det_Image_Save" == strCode) if ("Det_Image_Save" == strCode)
@ -984,7 +851,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{ {
_config.saveImg.Init(); _config.saveImg.Init();
} }
// _config.edgeDet.print("edgeDet"); // _config.pinDet.print("pinDet");
// getchar(); // getchar();
} }
if ("Big_NG" == strCode) if ("Big_NG" == strCode)
@ -1119,7 +986,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
{ {
_config.bigNG.Init(); _config.bigNG.Init();
} }
// _config.edgeDet.print("edgeDet"); // _config.pinDet.print("pinDet");
// getchar(); // getchar();
} }
return 0; return 0;

Write Preview
Loading…
Cancel
Save