You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
993 lines
43 KiB
993 lines
43 KiB
#include "JsonConfig.h"
|
|
|
|
Json::Value CommonParamJson::toJsonValue()
|
|
{
|
|
return Json::Value();
|
|
}
|
|
|
|
void CommonParamJson::toObjectFromValue(Json::Value root)
|
|
{
|
|
_config.image = root["image"].asString();
|
|
_config.skuName = root["sku_name"].asString();
|
|
_config.value = root["value"].asString();
|
|
}
|
|
|
|
int CommonParamJson::GetConfig(CommonParamST &config)
|
|
{
|
|
config.copy(_config);
|
|
return 0;
|
|
}
|
|
|
|
Json::Value CommonParamToCheckConfigJson::toJsonValue()
|
|
{
|
|
return Json::Value();
|
|
}
|
|
|
|
// 读取和图片相关的参数
|
|
void CommonParamToCheckConfigJson::toObjectFromValue(Json::Value root)
|
|
{
|
|
|
|
auto strJson = root.asString();
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value rootvalue;
|
|
std::string err;
|
|
// std::cout << strJson << std::endl;
|
|
auto nSize = strJson.size();
|
|
if (reader->parse(strJson.c_str(), strJson.c_str() + nSize, &rootvalue, &err))
|
|
{
|
|
|
|
// 和节点无关参数提取
|
|
{
|
|
auto value = rootvalue["base"];
|
|
// std::cout << value << std::endl;
|
|
// getchar();
|
|
if (value.isObject())
|
|
{
|
|
_config.baseConfig.image_widht = value["image_widht"].asInt();
|
|
_config.baseConfig.Image_height = value["Image_height"].asInt();
|
|
_config.baseConfig.bDrawShieldRoi = value["bDrawShieldRoi"].asBool();
|
|
_config.baseConfig.bDrawPreRoi = value["Draw_PreROI"].asBool();
|
|
_config.baseConfig.bShield_ZF = value["bShield_ZF"].asBool();
|
|
_config.baseConfig.fUP_IOU = value["UP_IOU"].asFloat();
|
|
_config.baseConfig.strCamName = value["cameraCode"].asString();
|
|
_config.baseConfig.strCamearName = value["cameraCode"].asString();
|
|
_config.baseConfig.bCal_ImageScale = value["bImageScale_Cal"].asBool();
|
|
_config.baseConfig.Product_Size_Width_mm = value["Product_Size_W"].asFloat();
|
|
_config.baseConfig.Product_Size_Height_mm = value["Product_Size_H"].asFloat();
|
|
_config.baseConfig.fImage_Scale_x = value["Image_Scale_X"].asFloat();
|
|
_config.baseConfig.fImage_Scale_y = value["Image_Scale_Y"].asFloat();
|
|
if (value["Density_R"])
|
|
{
|
|
_config.baseConfig.density_R_mm = value["Density_R"].asFloat();
|
|
if (_config.baseConfig.density_R_mm <= 0 || _config.baseConfig.density_R_mm > 99999)
|
|
{
|
|
_config.baseConfig.density_R_mm = 5;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// 读取每个节点的参数
|
|
{
|
|
auto value_node = rootvalue["node"];
|
|
// 读取每个节点的参数
|
|
for (int i = 0; i < value_node.size(); i++)
|
|
{
|
|
printf("Node idx %d /%d \n", i, value_node.size());
|
|
|
|
CommonConfigNodeST tem_node;
|
|
// 和节点相关基础参数
|
|
{
|
|
auto value_node_base = value_node[i]["node_base"];
|
|
// std::cout << value_node_base << std::endl;
|
|
|
|
if (value_node_base.isObject())
|
|
{
|
|
|
|
tem_node.nodebasicConfog.calss_conf = value_node_base["class_conf"].asFloat();
|
|
tem_node.nodebasicConfog.calss_area = value_node_base["Class_AreaT"].asFloat();
|
|
|
|
// tem_node.nodebasicConfog.print("nodebasicConfog");
|
|
}
|
|
}
|
|
|
|
// 读取当前节点下 的每张图片 一般只读第一张图
|
|
{
|
|
auto value_node_imgs = value_node[i]["node_images"];
|
|
|
|
if (value_node_imgs.size() > 0)
|
|
{
|
|
int img_idx = 0;
|
|
tem_node.nodebasicConfog.img_width = value_node_imgs[img_idx]["width"].asInt();
|
|
tem_node.nodebasicConfog.img_height = value_node_imgs[img_idx]["height"].asInt();
|
|
|
|
auto value_node_imgs_region = value_node_imgs[img_idx]["params"];
|
|
// printf("tem_node.img_height %d, tem_node.img_width %d region num %d\n",
|
|
// tem_node.nodebasicConfog.img_height,
|
|
// tem_node.nodebasicConfog.img_width,
|
|
// value_node_imgs_region.size());
|
|
|
|
for (int region_idx = 0; region_idx < value_node_imgs_region.size(); region_idx++)
|
|
{
|
|
// printf("region idx %d /%d \n", region_idx, value_node_imgs_region.size());
|
|
|
|
RegionConfigST temRegion;
|
|
temRegion.buse = true;
|
|
// 1、读取基本参数
|
|
{
|
|
auto value_node_imgs_region_base = value_node_imgs_region[region_idx];
|
|
// std::cout<<value_node_imgs_region_base<<std::endl;
|
|
if (value_node_imgs_region_base.isObject())
|
|
{
|
|
temRegion.basicInfo.lay = value_node_imgs_region_base["tier"].asInt();
|
|
temRegion.basicInfo.type = value_node_imgs_region_base["areaType"].asInt();
|
|
temRegion.basicInfo.name = value_node_imgs_region_base["en_name"].asString();
|
|
temRegion.basicInfo.bdraw = value_node_imgs_region_base["bdraw"].asInt();
|
|
// printf("--- tier %d type %d\n ", temRegion.basicInfo.lay, temRegion.basicInfo.type);
|
|
}
|
|
}
|
|
// 读取通道
|
|
{
|
|
auto value_node_imgs_region_chanel = value_node_imgs_region[region_idx]["Channel_Param"]["channel"];
|
|
if (value_node_imgs_region_chanel.isArray())
|
|
{
|
|
for (int idx = 0; idx < value_node_imgs_region_chanel.size(); idx++)
|
|
{
|
|
std::string str = value_node_imgs_region_chanel[idx].asString();
|
|
temRegion.basicInfo.ChannelArry.emplace_back(str);
|
|
}
|
|
}
|
|
}
|
|
// 2、读取区域点
|
|
{
|
|
auto value_node_imgs_region_coord = value_node_imgs_region[region_idx]["coord"];
|
|
if (value_node_imgs_region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < value_node_imgs_region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = value_node_imgs_region_coord[idx][0].asInt();
|
|
p.y = value_node_imgs_region_coord[idx][1].asInt();
|
|
if (p.x < 0)
|
|
{
|
|
p.x = 0;
|
|
}
|
|
if (p.x > tem_node.nodebasicConfog.img_width)
|
|
{
|
|
p.x = tem_node.nodebasicConfog.img_width;
|
|
}
|
|
if (p.y < 0)
|
|
{
|
|
p.y = 0;
|
|
}
|
|
if (p.y > tem_node.nodebasicConfog.img_height)
|
|
{
|
|
p.y = tem_node.nodebasicConfog.img_height;
|
|
}
|
|
temRegion.basicInfo.pointArry.emplace_back(p);
|
|
}
|
|
}
|
|
}
|
|
// 3、读取检测参数 和存图参数
|
|
for (int ParamType_idx = 0; ParamType_idx < ANALYSIS_TYPE_COUNT; ParamType_idx++)
|
|
{
|
|
if (temRegion.basicInfo.type == 1)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// int param_type = ParamType_idx;
|
|
|
|
auto value_node_imgs_region_Check_Param = value_node_imgs_region[region_idx][ANALYSIS_TYPE_Names[ParamType_idx]];
|
|
|
|
if (value_node_imgs_region_Check_Param.isObject())
|
|
{
|
|
|
|
for (Json::ValueIterator iter = value_node_imgs_region_Check_Param.begin(); iter != value_node_imgs_region_Check_Param.end(); iter++)
|
|
{
|
|
CheckConfig_Regions_Param tem_paramValue;
|
|
|
|
// const char *name = iter.memberName();
|
|
std::string name = iter.name(); // 新方法，推荐使用
|
|
tem_paramValue.param_name = name;
|
|
auto value_node_imgs_region_Check_Param_value = value_node_imgs_region_Check_Param[name];
|
|
|
|
if (value_node_imgs_region_Check_Param_value.isArray())
|
|
{
|
|
|
|
for (int idx = 0; idx < value_node_imgs_region_Check_Param_value.size(); idx++)
|
|
{
|
|
|
|
AandEParam temparam;
|
|
temparam.bEnable = value_node_imgs_region_Check_Param_value[idx]["state"].asBool();
|
|
temparam.bOk = value_node_imgs_region_Check_Param_value[idx]["bOK"].asBool();
|
|
if (value_node_imgs_region_Check_Param_value[idx]["area"])
|
|
{
|
|
temparam.area = value_node_imgs_region_Check_Param_value[idx]["area"].asFloat();
|
|
}
|
|
if (value_node_imgs_region_Check_Param_value[idx]["area_max"])
|
|
{
|
|
temparam.area_max = value_node_imgs_region_Check_Param_value[idx]["area_max"].asFloat();
|
|
}
|
|
if (value_node_imgs_region_Check_Param_value[idx]["energy"])
|
|
{
|
|
temparam.energy = value_node_imgs_region_Check_Param_value[idx]["energy"].asFloat();
|
|
}
|
|
|
|
if (value_node_imgs_region_Check_Param_value[idx]["hj"])
|
|
{
|
|
temparam.hj = value_node_imgs_region_Check_Param_value[idx]["hj"].asFloat();
|
|
}
|
|
|
|
if (value_node_imgs_region_Check_Param_value[idx]["length"])
|
|
{
|
|
temparam.length = value_node_imgs_region_Check_Param_value[idx]["length"].asFloat();
|
|
}
|
|
|
|
if (value_node_imgs_region_Check_Param_value[idx]["breadth"])
|
|
{
|
|
temparam.breadth = value_node_imgs_region_Check_Param_value[idx]["breadth"].asFloat();
|
|
}
|
|
|
|
if (value_node_imgs_region_Check_Param_value[idx]["num"])
|
|
{
|
|
temparam.num = value_node_imgs_region_Check_Param_value[idx]["num"].asInt();
|
|
}
|
|
|
|
if (value_node_imgs_region_Check_Param_value[idx]["dis"])
|
|
{
|
|
temparam.dis = value_node_imgs_region_Check_Param_value[idx]["dis"].asFloat();
|
|
}
|
|
if (value_node_imgs_region_Check_Param_value[idx]["density"])
|
|
{
|
|
temparam.density = value_node_imgs_region_Check_Param_value[idx]["density"].asFloat();
|
|
}
|
|
std::string str = ANALYSIS_TYPE_Names[ParamType_idx] + " " + name + " " + std::to_string(idx);
|
|
// temparam.print(str);
|
|
tem_paramValue.addParam(temparam);
|
|
}
|
|
}
|
|
temRegion.checkConfig_Regions_type[ParamType_idx].checkConfig_Regions_Param.push_back(tem_paramValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
tem_node.regionConfigArr.push_back(temRegion);
|
|
}
|
|
}
|
|
}
|
|
|
|
_config.nodeConfigArr.push_back(tem_node);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("--- ******error json*** \n");
|
|
}
|
|
}
|
|
int CommonParamToCheckConfigJson::GetConfig(CommonCheckConfigST &config)
|
|
{
|
|
config.copy(_config);
|
|
return 0;
|
|
}
|
|
|
|
Json::Value CheckConfigJson::toJsonValue()
|
|
{
|
|
return Json::Value();
|
|
}
|
|
|
|
void CheckConfigJson::toObjectFromValue(Json::Value root)
|
|
{
|
|
{
|
|
auto value = root["AI_Model_Path"];
|
|
if (value.isObject())
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
{
|
|
auto value = root["image_preprocess_param"];
|
|
if (value.isObject())
|
|
{
|
|
auto arr = value["crop_roi"];
|
|
if (arr.isArray())
|
|
{
|
|
_config.preDealImgConfig.cutRoi.x = arr[0].asInt();
|
|
_config.preDealImgConfig.cutRoi.y = arr[1].asInt();
|
|
_config.preDealImgConfig.cutRoi.width = arr[2].asInt();
|
|
_config.preDealImgConfig.cutRoi.height = arr[3].asInt();
|
|
}
|
|
_config.preDealImgConfig.bresize = value["resize"].asBool();
|
|
_config.preDealImgConfig.bInAI_ImgFflip = value["ai_input_image_flip"].asBool();
|
|
_config.preDealImgConfig.bOutAI_ImgFflip = value["ai_output_image_flip"].asBool();
|
|
}
|
|
}
|
|
{
|
|
auto value = root["Camer_param"];
|
|
if (value.isObject())
|
|
{
|
|
|
|
_config.camConfig.fscale_x = value["scale_x"].asFloat();
|
|
_config.camConfig.fscale_y = value["scale_y"].asFloat();
|
|
|
|
std::cout << "_config.camConfig.fscale_x=" << _config.camConfig.fscale_x << std::endl;
|
|
std::cout << "_config.camConfig.fscale_y=" << _config.camConfig.fscale_y << std::endl;
|
|
}
|
|
}
|
|
{
|
|
auto value = root["image_Info"];
|
|
if (value.isObject())
|
|
{
|
|
|
|
_config.resultimg_out.width = value["result_image_width"].asInt();
|
|
_config.resultimg_out.height = value["result_image_height"].asInt();
|
|
_config.resultimg_out.channels = value["result_image_channels"].asInt();
|
|
|
|
_config.resultimg_out.print("resultimg_out");
|
|
|
|
_config.Srcimg_in.width = value["src_image_width"].asInt();
|
|
_config.Srcimg_in.height = value["src_image_height"].asInt();
|
|
_config.Srcimg_in.channels = value["src_image_channels"].asInt();
|
|
|
|
_config.Srcimg_in.print("Srcimg_in");
|
|
}
|
|
}
|
|
}
|
|
int CheckConfigJson::GetConfig(CheckConfigST &config)
|
|
{
|
|
config.copy(_config);
|
|
return 0;
|
|
}
|
|
|
|
Json::Value ChannelFuntonConfigJson::toJsonValue()
|
|
{
|
|
return Json::Value();
|
|
}
|
|
|
|
void ChannelFuntonConfigJson::toObjectFromValue(Json::Value root)
|
|
{
|
|
auto strJson = root.asString();
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value rootvalue;
|
|
std::string err;
|
|
// std::cout << "ChannelFuntonConfigJson" << std::endl
|
|
// << std::endl
|
|
// << std::endl;
|
|
// std::cout << strJson << std::endl;
|
|
auto nSize = strJson.size();
|
|
|
|
if (reader->parse(strJson.c_str(), strJson.c_str() + nSize, &rootvalue, &err))
|
|
{
|
|
// 和节点无关参数提取
|
|
|
|
auto value = rootvalue["checkData"];
|
|
if (value.isArray())
|
|
{
|
|
for (int idx = 0; idx < value.size(); idx++)
|
|
{
|
|
ChannelCheckFunction channel;
|
|
if (value[idx]["panelCode"])
|
|
{
|
|
channel.strChannelName = value[idx]["panelCode"].asString();
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
GetFunction(value[idx]["checkItem"], channel.function);
|
|
|
|
// up 特殊处理
|
|
if (channel.strChannelName == "Up-Particle" && channel.function.f_BaseDet.bOpen)
|
|
{
|
|
channel.function.f_OnlyBLob.bOpen = true;
|
|
}
|
|
|
|
// channel.print("channel");
|
|
// getchar();
|
|
_config.channelFunctionArr.push_back(channel);
|
|
}
|
|
// _config.print("channelFunction");
|
|
}
|
|
}
|
|
}
|
|
|
|
int ChannelFuntonConfigJson::GetConfig(ALLChannelCheckFunction &config)
|
|
{
|
|
config.copy(_config);
|
|
return 0;
|
|
}
|
|
|
|
int ChannelFuntonConfigJson::GetFunction(Json::Value value, CheckFunction &function)
|
|
{
|
|
// std::cout << value << std::endl;
|
|
|
|
if (value.isArray())
|
|
{
|
|
for (int i = 0; i < value.size(); i++)
|
|
{
|
|
|
|
std::string strCode = value[i]["itemCode"].asString();
|
|
// std::cout << strCode << std::endl;
|
|
// 大缺陷检测
|
|
if ("BigQX_Detect" == strCode)
|
|
{
|
|
auto value_f = value[i];
|
|
// std::cout << value_f << std::endl;
|
|
function.f_Big_QX.bOpen = value_f["isOpen"].asBool();
|
|
if (value_f["form"]["SingleConfig"]["Area"])
|
|
{
|
|
function.f_Big_QX.Single_Area = value_f["form"]["SingleConfig"]["Area"].asFloat();
|
|
}
|
|
if (value_f["form"]["SingleConfig"]["HJ"])
|
|
{
|
|
function.f_Big_QX.Single_HJ = value_f["form"]["SingleConfig"]["HJ"].asInt();
|
|
}
|
|
if (value_f["form"]["SingleConfig"]["Length"])
|
|
{
|
|
function.f_Big_QX.Single_Len = value_f["form"]["SingleConfig"]["Length"].asFloat();
|
|
}
|
|
if (value_f["form"]["Sum_Area"]["Blob_Num"])
|
|
{
|
|
function.f_Big_QX.Sum_blob_Num = value_f["form"]["Sum_Area"]["Blob_Num"].asInt();
|
|
}
|
|
if (value_f["form"]["Sum_Area"]["Area_Sum"])
|
|
{
|
|
function.f_Big_QX.Sum_Area = value_f["form"]["Sum_Area"]["Area_Sum"].asFloat();
|
|
}
|
|
}
|
|
// 屏蔽区域
|
|
if ("ShieldRegion" == strCode)
|
|
{
|
|
auto value_f = value[i];
|
|
// std::cout << value_f << std::endl;
|
|
function.f_ShieldRegion.bOpen = value_f["isOpen"].asBool();
|
|
if (function.f_ShieldRegion.bOpen)
|
|
{
|
|
/* code */
|
|
|
|
if (value_f["form"]["ShieldRegionConfig"]["bDraw"])
|
|
{
|
|
function.f_ShieldRegion.bDraw = value_f["form"]["ShieldRegionConfig"]["bDraw"].asBool();
|
|
}
|
|
{
|
|
auto region_coord = value_f["form"]["ShieldRegionConfig"]["region_1"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_ShieldRegion.pointArry1.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
|
|
{
|
|
auto region_coord = value_f["form"]["ShieldRegionConfig"]["region_2"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_ShieldRegion.pointArry2.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry2 size %d \n", function.f_ShieldRegion.pointArry2.size());
|
|
}
|
|
{
|
|
auto region_coord = value_f["form"]["ShieldRegionConfig"]["region_3"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_ShieldRegion.pointArry3.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry3 size %d \n", function.f_ShieldRegion.pointArry3.size());
|
|
}
|
|
{
|
|
auto region_coord = value_f["form"]["ShieldRegionConfig"]["region_4"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_ShieldRegion.pointArry4.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry4 size %d \n", function.f_ShieldRegion.pointArry4.size());
|
|
}
|
|
{
|
|
auto region_coord = value_f["form"]["ShieldRegionConfig"]["region_5"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_ShieldRegion.pointArry5.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry5 size %d \n", function.f_ShieldRegion.pointArry5.size());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
function.f_ShieldRegion.Init();
|
|
}
|
|
}
|
|
// 边缘roi
|
|
if ("Crop_ROI" == strCode)
|
|
{
|
|
auto value_f = value[i];
|
|
// std::cout << value_f << std::endl;
|
|
function.f_EdgeROI.bOpen = value_f["isOpen"].asBool();
|
|
if (function.f_EdgeROI.bOpen)
|
|
{
|
|
/* code */
|
|
|
|
if (value_f["form"]["ROI_Config"]["Use_DrawROI"])
|
|
{
|
|
function.f_EdgeROI.Use_DrawROI = value_f["form"]["ROI_Config"]["Use_DrawROI"].asBool();
|
|
}
|
|
if (value_f["form"]["ROI_Config"]["Use_DetEdge"])
|
|
{
|
|
function.f_EdgeROI.Use_DetEdge = value_f["form"]["ROI_Config"]["Use_DetEdge"].asBool();
|
|
}
|
|
if (value_f["form"]["ROI_Config"]["Use_AIEdge"])
|
|
{
|
|
function.f_EdgeROI.Use_AIEdge = value_f["form"]["ROI_Config"]["Use_AIEdge"].asBool();
|
|
}
|
|
if (value_f["form"]["ROI_Config"]["AI_Fail_UseDraw"])
|
|
{
|
|
function.f_EdgeROI.AI_Fail_UseDraw = value_f["form"]["ROI_Config"]["AI_Fail_UseDraw"].asBool();
|
|
}
|
|
if (value_f["form"]["ROI_Config"]["threshold_value"])
|
|
{
|
|
function.f_EdgeROI.threshold_value = value_f["form"]["ROI_Config"]["threshold_value"].asInt();
|
|
}
|
|
if (value_f["form"]["ROI_Config"]["threshold_value"])
|
|
{
|
|
function.f_EdgeROI.AI_Erode_Size = value_f["form"]["ROI_Config"]["AI_Erode_Size"].asInt();
|
|
}
|
|
{
|
|
auto region_coord = value_f["form"]["ROI_Config"]["ROI"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_EdgeROI.pointArry1.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
function.f_EdgeROI.Init();
|
|
}
|
|
}
|
|
// 边缘roi
|
|
if ("Image_Align_T" == strCode)
|
|
{
|
|
auto value_f = value[i];
|
|
// std::cout << value_f << std::endl;
|
|
function.f_Image_Align.bOpen = value_f["isOpen"].asBool();
|
|
if (function.f_Image_Align.bOpen)
|
|
{
|
|
/* code */
|
|
|
|
{
|
|
auto region_coord = value_f["form"]["Align_Config"]["Edge_TZ"];
|
|
if (region_coord.isArray())
|
|
{
|
|
for (int idx = 0; idx < region_coord.size(); idx++)
|
|
{
|
|
cv::Point p;
|
|
p.x = region_coord[idx][0].asInt();
|
|
p.y = region_coord[idx][1].asInt();
|
|
function.f_Image_Align.pointArry1.emplace_back(p);
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
{
|
|
auto region_roi = value_f["form"]["Align_Config"]["Search_ROI"];
|
|
|
|
{
|
|
if (region_roi["x"])
|
|
{
|
|
function.f_Image_Align.search_Roi.x = region_roi["x"].asInt();
|
|
}
|
|
if (region_roi["y"])
|
|
{
|
|
function.f_Image_Align.search_Roi.y = region_roi["y"].asInt();
|
|
}
|
|
if (region_roi["width"])
|
|
{
|
|
function.f_Image_Align.search_Roi.width = region_roi["width"].asInt();
|
|
}
|
|
if (region_roi["height"])
|
|
{
|
|
function.f_Image_Align.search_Roi.height = region_roi["height"].asInt();
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
{
|
|
auto Kernel_roi = value_f["form"]["Align_Config"]["Kernel_ROI"];
|
|
|
|
{
|
|
if (Kernel_roi["x"])
|
|
{
|
|
function.f_Image_Align.feature_Roi.x = Kernel_roi["x"].asInt();
|
|
}
|
|
if (Kernel_roi["y"])
|
|
{
|
|
function.f_Image_Align.feature_Roi.y = Kernel_roi["y"].asInt();
|
|
}
|
|
if (Kernel_roi["width"])
|
|
{
|
|
function.f_Image_Align.feature_Roi.width = Kernel_roi["width"].asInt();
|
|
}
|
|
if (Kernel_roi["height"])
|
|
{
|
|
function.f_Image_Align.feature_Roi.height = Kernel_roi["height"].asInt();
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
{
|
|
auto crop_roi = value_f["form"]["Align_Config"]["Crop_ROI"];
|
|
|
|
{
|
|
if (crop_roi["x"])
|
|
{
|
|
function.f_Image_Align.Crop_Roi.x = crop_roi["x"].asInt();
|
|
}
|
|
if (crop_roi["y"])
|
|
{
|
|
function.f_Image_Align.Crop_Roi.y = crop_roi["y"].asInt();
|
|
}
|
|
if (crop_roi["width"])
|
|
{
|
|
function.f_Image_Align.Crop_Roi.width = crop_roi["width"].asInt();
|
|
}
|
|
if (crop_roi["height"])
|
|
{
|
|
function.f_Image_Align.Crop_Roi.height = crop_roi["height"].asInt();
|
|
}
|
|
}
|
|
// printf(" pointArry1 size %d \n", function.f_ShieldRegion.pointArry1.size());
|
|
}
|
|
{
|
|
if (value_f["form"]["Align_Config"]["bDraw"])
|
|
{
|
|
function.f_Image_Align.bDraw = value_f["form"]["Align_Config"]["bDraw"].asBool();
|
|
}
|
|
}
|
|
{
|
|
if (value_f["form"]["Align_Config"]["Score"])
|
|
{
|
|
float fs = value_f["form"]["Align_Config"]["Score"].asFloat();
|
|
if (fs > 0.01 && fs <= 1)
|
|
{
|
|
function.f_Image_Align.fscore = fs;
|
|
}
|
|
}
|
|
}
|
|
if (value_f["form"]["Align_Config"]["UseType"])
|
|
{
|
|
std::string str = value_f["form"]["Align_Config"]["UseType"].asString();
|
|
if (str == "Use")
|
|
{
|
|
function.f_Image_Align.runType = Function_Image_Align::type_Use;
|
|
}
|
|
else if (str == "Test")
|
|
{
|
|
function.f_Image_Align.runType = Function_Image_Align::type_Test;
|
|
}
|
|
else
|
|
{
|
|
function.f_Image_Align.runType = Function_Image_Align::type_Use;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
function.f_Image_Align.Init();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Json::Value BaseFuntonConfigJson::toJsonValue()
|
|
{
|
|
return Json::Value();
|
|
}
|
|
|
|
void BaseFuntonConfigJson::toObjectFromValue(Json::Value root)
|
|
{
|
|
auto strJson = root.asString();
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value rootvalue;
|
|
std::string err;
|
|
// std::cout << "BaseFuntonConfigJson" << std::endl
|
|
// << std::endl
|
|
// << std::endl;
|
|
// std::cout << strJson << std::endl;
|
|
auto nSize = strJson.size();
|
|
|
|
if (reader->parse(strJson.c_str(), strJson.c_str() + nSize, &rootvalue, &err))
|
|
{
|
|
// 和节点无关参数提取
|
|
|
|
auto value = rootvalue["baseCheckData"];
|
|
// printf("\n\n\n");
|
|
// std::cout << value << std::endl;
|
|
// getchar();
|
|
if (value.isArray())
|
|
{
|
|
for (int idx = 0; idx < value.size(); idx++)
|
|
{
|
|
GetFunction(value[idx]);
|
|
}
|
|
// _config.print("channelFunction");
|
|
}
|
|
}
|
|
}
|
|
|
|
int BaseFuntonConfigJson::GetConfig(BaseCheckFunction &config)
|
|
{
|
|
config.copy(_config);
|
|
return 0;
|
|
}
|
|
|
|
int BaseFuntonConfigJson::GetFunction(Json::Value value)
|
|
{
|
|
|
|
// std::cout << value << std::endl;
|
|
|
|
std::string strCode = value["itemCode"].asString();
|
|
// std::cout << strCode << std::endl;
|
|
// 读取UP 过滤功能
|
|
if ("AlignDet" == strCode)
|
|
{
|
|
auto value_f = value;
|
|
// std::cout << value_f << std::endl;
|
|
// getchar();
|
|
_config.ALign_Config.bOpen = value_f["isOpen"].asBool();
|
|
if (_config.ALign_Config.bOpen)
|
|
{
|
|
if (value_f["form"]["ALign_Config"]["angle_diff"])
|
|
{
|
|
_config.ALign_Config.angle_diff = value_f["form"]["ALign_Config"]["angle_diff"].asFloat();
|
|
}
|
|
if (value_f["form"]["ALign_Config"]["x_offset"])
|
|
{
|
|
_config.ALign_Config.x_offset = value_f["form"]["ALign_Config"]["x_offset"].asFloat();
|
|
}
|
|
if (value_f["form"]["ALign_Config"]["y_offset"])
|
|
{
|
|
_config.ALign_Config.y_offset = value_f["form"]["ALign_Config"]["y_offset"].asFloat();
|
|
}
|
|
|
|
if (value_f["form"]["ALign_Config"]["len"])
|
|
{
|
|
_config.ALign_Config.len = value_f["form"]["ALign_Config"]["len"].asFloat();
|
|
}
|
|
if (value_f["form"]["ALign_Config"]["width"])
|
|
{
|
|
_config.ALign_Config.width = value_f["form"]["ALign_Config"]["width"].asFloat();
|
|
}
|
|
if (value_f["form"]["ALign_Config"]["len_diff"])
|
|
{
|
|
_config.ALign_Config.len_diff = value_f["form"]["ALign_Config"]["len_diff"].asFloat();
|
|
}
|
|
if (value_f["form"]["ALign_Config"]["width_diff"])
|
|
{
|
|
_config.ALign_Config.width_diff = value_f["form"]["ALign_Config"]["width_diff"].asFloat();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_config.ALign_Config.Init();
|
|
}
|
|
}
|
|
if ("Pin_QX_Detect" == strCode)
|
|
{
|
|
auto value_f = value;
|
|
// std::cout << value_f << std::endl;
|
|
// getchar();
|
|
_config.pinDet.bOpen = value_f["isOpen"].asBool();
|
|
if (_config.pinDet.bOpen)
|
|
{
|
|
|
|
if (value_f["form"]["Det_Config"]["pin_x_offset"])
|
|
{
|
|
_config.pinDet.pin_x_offset = value_f["form"]["Det_Config"]["pin_x_offset"].asFloat();
|
|
}
|
|
if (value_f["form"]["Det_Config"]["pin_y_offset"])
|
|
{
|
|
_config.pinDet.pin_y_offset = value_f["form"]["Det_Config"]["pin_y_offset"].asFloat();
|
|
}
|
|
if (value_f["form"]["otherConfig"]["bDrawResult"])
|
|
{
|
|
_config.pinDet.bDrawResult = value_f["form"]["otherConfig"]["bDrawResult"].asBool();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_config.pinDet.Init();
|
|
}
|
|
// _config.pinDet.print("pinDet");
|
|
// getchar();
|
|
}
|
|
if ("KK_Image_Save" == strCode)
|
|
{
|
|
auto value_f = value;
|
|
// std::cout << value_f << std::endl;
|
|
// getchar();
|
|
_config.saveImg.bOpen = value_f["isOpen"].asBool();
|
|
if (_config.saveImg.bOpen)
|
|
{
|
|
|
|
if (value_f["form"]["SaveImg_Config"]["Cls_Save"])
|
|
{
|
|
_config.saveImg.bSaveClsImg = value_f["form"]["SaveImg_Config"]["Cls_Save"].asBool();
|
|
}
|
|
if (value_f["form"]["SaveImg_Config"]["Align_Big_Save"])
|
|
{
|
|
_config.saveImg.bSaveAlginImg = value_f["form"]["SaveImg_Config"]["Align_Big_Save"].asBool();
|
|
}
|
|
if (value_f["form"]["SaveImg_Config"]["Align_Pin_Save"])
|
|
{
|
|
_config.saveImg.bSavePinImg = value_f["form"]["SaveImg_Config"]["Align_Pin_Save"].asBool();
|
|
}
|
|
if (value_f["form"]["SaveImg_Config"]["AI_Det_Save"])
|
|
{
|
|
_config.saveImg.bSaveAIDetImg = value_f["form"]["SaveImg_Config"]["AI_Det_Save"].asBool();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_config.saveImg.Init();
|
|
}
|
|
// _config.pinDet.print("pinDet");
|
|
// getchar();
|
|
}
|
|
if ("bMerge_QueXi" == strCode)
|
|
{
|
|
auto value_f = value;
|
|
// std::cout << value_f << std::endl;
|
|
// getchar();
|
|
_config.Merge_QueXi.bOpen = value_f["isOpen"].asBool();
|
|
}
|
|
|
|
if ("Big_NG" == strCode)
|
|
{
|
|
auto value_f = value;
|
|
// std::cout << value_f << std::endl;
|
|
// getchar();
|
|
_config.bigNG.bOpen = value_f["isOpen"].asBool();
|
|
if (_config.bigNG.bOpen)
|
|
{
|
|
if (value_f["form"]["PIN_PoSun"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].bOpen = value_f["form"]["PIN_PoSun"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["PIN_PoSun"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].fArea = value_f["form"]["PIN_PoSun"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PoSun].strname = "PIN_PoSun";
|
|
|
|
if (value_f["form"]["PIN_QueShi"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].bOpen = value_f["form"]["PIN_QueShi"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["PIN_QueShi"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].fArea = value_f["form"]["PIN_QueShi"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_QueShi].strname = "PIN_QueShi";
|
|
|
|
if (value_f["form"]["BTB_DuanLie"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].bOpen = value_f["form"]["BTB_DuanLie"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["BTB_DuanLie"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].fArea = value_f["form"]["BTB_DuanLie"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_BTB_DuanLie].strname = "BTB_DuanLie";
|
|
|
|
if (value_f["form"]["LianXi"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].bOpen = value_f["form"]["LianXi"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["LianXi"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].fArea = value_f["form"]["LianXi"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_LianXi].strname = "LianXi";
|
|
|
|
if (value_f["form"]["QueXi"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].bOpen = value_f["form"]["QueXi"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["QueXi"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].fArea = value_f["form"]["QueXi"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_QueXi].strname = "QueXi";
|
|
|
|
if (value_f["form"]["YiWu"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].bOpen = value_f["form"]["YiWu"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["YiWu"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].fArea = value_f["form"]["YiWu"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_YiWu].strname = "YiWu";
|
|
|
|
if (value_f["form"]["C_BianXing"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].bOpen = value_f["form"]["C_BianXing"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["C_BianXing"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].fArea = value_f["form"]["C_BianXing"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_C_BianXing].strname = "C_BianXing";
|
|
|
|
if (value_f["form"]["PIN_PianYi"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PianYi].bOpen = value_f["form"]["PIN_PianYi"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["PIN_PianYi"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PianYi].fArea = value_f["form"]["PIN_PianYi"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_PIN_PianYi].strname = "PIN_PianYi";
|
|
|
|
if (value_f["form"]["Panel"]["open"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_Panel].bOpen = value_f["form"]["Panel"]["open"].asBool();
|
|
}
|
|
if (value_f["form"]["Panel"]["Area"])
|
|
{
|
|
_config.bigNG.qx[CONFIG_QX_NAME_Panel].fArea = value_f["form"]["Panel"]["Area"].asFloat();
|
|
}
|
|
_config.bigNG.qx[CONFIG_QX_NAME_Panel].strname = "Panel";
|
|
}
|
|
else
|
|
{
|
|
_config.bigNG.Init();
|
|
}
|
|
// _config.pinDet.print("pinDet");
|
|
// getchar();
|
|
}
|
|
return 0;
|
|
}
|