|
|
/*
|
|
|
* FileName:CoreLogicFactory.cpp
|
|
|
* Version:V1.0
|
|
|
* Description:
|
|
|
* Created On:Mon Sep 10 11:13:16 UTC 2018
|
|
|
* Modified date:
|
|
|
* Author:Sky
|
|
|
*/
|
|
|
#include "CheckUtil.hpp"
|
|
|
#include <sys/time.h>
|
|
|
#include <stdio.h>
|
|
|
#include <iostream>
|
|
|
#include <sys/types.h>
|
|
|
#include <sys/stat.h>
|
|
|
#include <unistd.h>
|
|
|
#include <string>
|
|
|
#include <sstream>
|
|
|
#include <sys/statfs.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <fstream>
|
|
|
#include <thread>
|
|
|
#include "snowflake.hpp"
|
|
|
|
|
|
int _sysmkdir_2(const std::string &dir)
|
|
|
{
|
|
|
int ret = mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
|
|
|
if (ret && errno == EEXIST)
|
|
|
{
|
|
|
// printf("dir[%s] already exist.\n", dir.c_str());
|
|
|
}
|
|
|
else if (ret)
|
|
|
{
|
|
|
printf("create dir[%s] error: %d %s\n", dir.c_str(), ret, strerror(errno));
|
|
|
return -1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("create dir[%s] success.\n", dir.c_str());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
std::string __getParentDir_2(const std::string &dir)
|
|
|
{
|
|
|
std::string pdir = dir;
|
|
|
if (pdir.length() < 1 || (pdir[0] != '/'))
|
|
|
{
|
|
|
return "";
|
|
|
}
|
|
|
while (pdir.length() > 1 && (pdir[pdir.length() - 1] == '/'))
|
|
|
pdir = pdir.substr(0, pdir.length() - 1);
|
|
|
|
|
|
pdir = pdir.substr(0, pdir.find_last_of('/'));
|
|
|
return pdir;
|
|
|
}
|
|
|
|
|
|
long CheckUtil::getcurTime()
|
|
|
{
|
|
|
struct timeval tv;
|
|
|
gettimeofday(&tv, NULL);
|
|
|
return ((long)tv.tv_sec) * 1000 + ((long)tv.tv_usec) / 1000;
|
|
|
}
|
|
|
std::string CheckUtil::getCurrentDate()
|
|
|
{
|
|
|
struct timeval tv;
|
|
|
gettimeofday(&tv, NULL); // 获取当前时间
|
|
|
|
|
|
// 将 tv_sec 转换为 time_t 类型，代表自1970年1月1日起的秒数
|
|
|
time_t raw_time = tv.tv_sec;
|
|
|
|
|
|
// 使用 localtime 将 time_t 转换为 tm 结构体
|
|
|
struct tm *time_info = localtime(&raw_time);
|
|
|
|
|
|
// 使用字符串流格式化为 "YYYY-MM-DD"
|
|
|
std::ostringstream oss;
|
|
|
oss << (time_info->tm_year + 1900) << "-" // tm_year 是从1900年开始的
|
|
|
<< (time_info->tm_mon + 1) << "-" // tm_mon 是从0开始的
|
|
|
<< time_info->tm_mday; // tm_mday 是当前月的天数
|
|
|
|
|
|
return oss.str(); // 返回日期字符串
|
|
|
}
|
|
|
std::string CheckUtil::getCurTimeHMS()
|
|
|
{
|
|
|
struct timeval tv;
|
|
|
gettimeofday(&tv, NULL); // 获取当前时间
|
|
|
|
|
|
time_t raw_time = tv.tv_sec;
|
|
|
struct tm *time_info = localtime(&raw_time);
|
|
|
|
|
|
int millisec = tv.tv_usec / 1000; // 微秒转毫秒
|
|
|
|
|
|
std::ostringstream oss;
|
|
|
oss << std::setfill('0') << std::setw(2) << time_info->tm_hour << ":"
|
|
|
<< std::setfill('0') << std::setw(2) << time_info->tm_min << ":"
|
|
|
<< std::setfill('0') << std::setw(2) << time_info->tm_sec << "."
|
|
|
<< std::setfill('0') << std::setw(3) << millisec;
|
|
|
|
|
|
return oss.str(); // 返回格式 "HH:MM:SS.mmm"
|
|
|
}
|
|
|
std::string CheckUtil::Op_float2String(float nvalue)
|
|
|
{
|
|
|
char buffer[20];
|
|
|
sprintf(buffer, "%.1f", nvalue);
|
|
|
std::string st1 = buffer;
|
|
|
return st1;
|
|
|
}
|
|
|
|
|
|
int64_t CheckUtil::getSnowId()
|
|
|
{
|
|
|
using snowflake_t = snowflake<1534832906275L, std::mutex>;
|
|
|
static snowflake_t uuid;
|
|
|
static bool bInit = false;
|
|
|
if (!bInit)
|
|
|
{
|
|
|
uuid.init(1, 1);
|
|
|
bInit = true;
|
|
|
}
|
|
|
return uuid.nextid();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
bool CheckUtil::JudgRect(cv::Rect roi, int img_w, int img_h)
|
|
|
{
|
|
|
if (img_w <= 0 || img_h <= 0)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.x < 0 || roi.x >= img_w)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.width <= 0 || roi.width >= img_w)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.y < 0 || roi.y >= img_h)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.height <= 0 || roi.height >= img_h)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.x + roi.width >= img_w)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.y + roi.height >= img_h)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool CheckUtil::JudgRect_SZ(cv::Rect roi, int w, int h)
|
|
|
{
|
|
|
if (roi.x < 0 || roi.x >= w)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.width <= 0 || roi.width != w)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.y < 0 || roi.y >= h)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
if (roi.height <= 0 || roi.height != h)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
bool CheckUtil::compareIgnoreCase(const std::string &str1, const std::string &str2)
|
|
|
{
|
|
|
// 将 str1 和 str2 转换为小写后进行比较
|
|
|
std::string lower_str1 = str1;
|
|
|
std::string lower_str2 = str2;
|
|
|
|
|
|
// 使用 std::transform 将字符串转换为小写
|
|
|
std::transform(lower_str1.begin(), lower_str1.end(), lower_str1.begin(), ::tolower);
|
|
|
std::transform(lower_str2.begin(), lower_str2.end(), lower_str2.begin(), ::tolower);
|
|
|
|
|
|
// 比较两个转换后的字符串
|
|
|
return lower_str1 == lower_str2;
|
|
|
}
|
|
|
|
|
|
bool CheckUtil::RoiInImg(cv::Rect roi, cv::Mat img)
|
|
|
{
|
|
|
if (roi.width <= 0 || roi.height <= 0)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
if ((roi & cv::Rect(0, 0, img.cols, img.rows)) == roi)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::printROI(cv::Rect roi, std::string str)
|
|
|
{
|
|
|
printf("%s x %d y %d w %d h %d\n", str.c_str(), roi.x, roi.y, roi.width, roi.height);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
float CheckUtil::CalIoU(cv::Rect rect1, cv::Rect rect2)
|
|
|
{
|
|
|
// 计算交集区域
|
|
|
cv::Rect intersection = rect1 & rect2;
|
|
|
|
|
|
// 计算并集区域
|
|
|
cv::Rect union_rect = rect1 | rect2;
|
|
|
|
|
|
// 计算交集区域和并集区域的面积
|
|
|
double intersection_area = intersection.area();
|
|
|
double union_area = union_rect.area();
|
|
|
|
|
|
// 计算IoU值
|
|
|
double iou = intersection_area / union_area;
|
|
|
|
|
|
return iou;
|
|
|
}
|
|
|
|
|
|
float CheckUtil::CalIoU_t(cv::Rect rect1, cv::Rect rect2)
|
|
|
{
|
|
|
// 计算交集区域
|
|
|
cv::Rect intersection = rect1 & rect2;
|
|
|
|
|
|
// 计算并集区域
|
|
|
cv::Rect union_rect = rect1;
|
|
|
|
|
|
// 计算交集区域和并集区域的面积
|
|
|
double intersection_area = intersection.area();
|
|
|
double union_area = union_rect.area();
|
|
|
|
|
|
// 计算IoU值
|
|
|
double iou = intersection_area / union_area;
|
|
|
|
|
|
return iou;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::CheckRect(cv::Rect &roi, int img_w, int img_h)
|
|
|
{
|
|
|
if (roi.x < 0 || roi.x >= img_w)
|
|
|
{
|
|
|
roi.x = 0;
|
|
|
}
|
|
|
if (roi.y < 0 || roi.y >= img_h)
|
|
|
{
|
|
|
roi.y = 0;
|
|
|
}
|
|
|
if (roi.width <= 0 || roi.width > img_w)
|
|
|
{
|
|
|
roi.width = 1;
|
|
|
}
|
|
|
if (roi.height <= 0 || roi.height > img_h)
|
|
|
{
|
|
|
roi.height = 1;
|
|
|
}
|
|
|
if (roi.x + roi.width > img_w)
|
|
|
{
|
|
|
roi.x = img_w - roi.width;
|
|
|
if (roi.x < 0)
|
|
|
{
|
|
|
roi.x = 0;
|
|
|
roi.width = img_w;
|
|
|
}
|
|
|
}
|
|
|
if (roi.y + roi.height > img_h)
|
|
|
{
|
|
|
roi.y = img_h - roi.height;
|
|
|
if (roi.y < 0)
|
|
|
{
|
|
|
roi.y = 0;
|
|
|
roi.height = img_h;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::SizeRect(cv::Rect &roi, int img_w, int img_h, int addw, int addh)
|
|
|
{
|
|
|
if (roi.width + 2 * addw > img_w)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
if (roi.height + 2 * addh > img_h)
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
int sx = roi.x - addw;
|
|
|
int ex = roi.x + roi.width + addw;
|
|
|
if (sx < 0)
|
|
|
{
|
|
|
sx = 0;
|
|
|
}
|
|
|
if (ex > img_w)
|
|
|
{
|
|
|
ex = img_w;
|
|
|
}
|
|
|
|
|
|
int sy = roi.y - addh;
|
|
|
int ey = roi.y + roi.height + addh;
|
|
|
if (sy < 0)
|
|
|
{
|
|
|
sy = 0;
|
|
|
}
|
|
|
if (ey > img_h)
|
|
|
{
|
|
|
ey = img_h;
|
|
|
}
|
|
|
|
|
|
roi.x = sx;
|
|
|
roi.width = ex - sx;
|
|
|
roi.y = sy;
|
|
|
roi.height = ey - sy;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::CalHj(const cv::Mat &img, const cv::Mat &mask, int b_value)
|
|
|
{
|
|
|
cv::Mat imgf;
|
|
|
if (img.type() != CV_32F)
|
|
|
img.convertTo(imgf, CV_32F);
|
|
|
else
|
|
|
imgf = img;
|
|
|
|
|
|
// 2. 减去常数并取绝对值
|
|
|
cv::Mat absDiff = cv::abs(imgf - b_value);
|
|
|
|
|
|
// 3. 用 mask 计算平均值
|
|
|
cv::Scalar meanValue123 = cv::mean(absDiff, mask);
|
|
|
|
|
|
return meanValue123[0];
|
|
|
}
|
|
|
|
|
|
int CheckUtil::CalHj(const cv::Mat &img, const cv::Mat &mask, const cv::Mat &backgroundimg)
|
|
|
{
|
|
|
cv::Mat imgf;
|
|
|
if (img.type() != CV_32F)
|
|
|
img.convertTo(imgf, CV_32F);
|
|
|
else
|
|
|
imgf = img;
|
|
|
|
|
|
cv::Scalar meanValue = cv::mean(backgroundimg);
|
|
|
int b_value = meanValue[0];
|
|
|
// 2. 减去常数并取绝对值
|
|
|
cv::Mat absDiff = cv::abs(imgf - b_value);
|
|
|
|
|
|
// 3. 用 mask 计算平均值
|
|
|
cv::Scalar meanValue123 = cv::mean(absDiff, mask);
|
|
|
|
|
|
return meanValue123[0];
|
|
|
}
|
|
|
|
|
|
int CheckUtil::CalHjWeighted(const cv::Mat &img, const cv::Mat &mask, int b_value, float power)
|
|
|
{
|
|
|
cv::Mat imgf;
|
|
|
if (img.type() != CV_32F)
|
|
|
img.convertTo(imgf, CV_32F);
|
|
|
else
|
|
|
imgf = img;
|
|
|
|
|
|
cv::Mat absDiff = cv::abs(imgf - b_value);
|
|
|
|
|
|
cv::Mat weight;
|
|
|
cv::pow(absDiff, power, weight);
|
|
|
|
|
|
cv::Mat maskedDiff, maskedWeight;
|
|
|
absDiff.copyTo(maskedDiff, mask);
|
|
|
weight.copyTo(maskedWeight, mask);
|
|
|
|
|
|
cv::Scalar weightedSum = cv::sum(maskedDiff.mul(weight));
|
|
|
cv::Scalar weightSum = cv::sum(maskedWeight);
|
|
|
|
|
|
if (weightSum[0] < 1e-6)
|
|
|
return 0;
|
|
|
|
|
|
return static_cast<int>(weightedSum[0] / weightSum[0]);
|
|
|
}
|
|
|
|
|
|
float CheckUtil::CalImgBrightness(cv::Mat imgRoi)
|
|
|
{
|
|
|
if (imgRoi.empty())
|
|
|
{
|
|
|
return 0.0f;
|
|
|
}
|
|
|
cv::Mat mat_mean, mat_stddev;
|
|
|
cv::meanStdDev(imgRoi, mat_mean, mat_stddev); // 求灰度图像的均值、均方差
|
|
|
float m = mat_mean.at<double>(0, 0);
|
|
|
return m;
|
|
|
}
|
|
|
|
|
|
float CheckUtil::Cal2PointAngle(cv::Point p_left, cv::Point p_right)
|
|
|
{
|
|
|
double angle = std::atan2(p_left.y - p_right.y, p_right.x - p_left.x);
|
|
|
return angle * 180 / 3.1415926;
|
|
|
}
|
|
|
|
|
|
float CheckUtil::getLongAxisAngle(cv::RotatedRect rect) {
|
|
|
// 获取宽度边对应的角度
|
|
|
float angle = rect.angle;
|
|
|
|
|
|
// 判断长轴：若 width >= height，长轴是 width 边；否则是 height 边（垂直于 width）
|
|
|
float long_axis_angle = (rect.size.width >= rect.size.height) ?
|
|
|
angle :
|
|
|
angle + 90.0f;
|
|
|
|
|
|
// 将角度归一化到 [0, 180) 范围（因为直线方向没有正反）
|
|
|
long_axis_angle = std::fmod(long_axis_angle, 180.0f);
|
|
|
if (long_axis_angle < 0) {
|
|
|
long_axis_angle += 180.0f;
|
|
|
}
|
|
|
return long_axis_angle;
|
|
|
}
|
|
|
|
|
|
std::vector<cv::Point2f> CheckUtil::sort_vertices(cv::RotatedRect rrect) {
|
|
|
cv::Point2f pts[4];
|
|
|
rrect.points(pts);
|
|
|
std::vector<cv::Point2f> vertices(pts, pts + 4);
|
|
|
|
|
|
// 按 y 坐标升序排序
|
|
|
std::sort(vertices.begin(), vertices.end(),
|
|
|
[](const cv::Point2f& a, const cv::Point2f& b) {
|
|
|
return a.y < b.y;
|
|
|
});
|
|
|
|
|
|
if (vertices[0].x > vertices[1].x)
|
|
|
std::swap(vertices[0], vertices[1]);
|
|
|
|
|
|
if (vertices[2].x > vertices[3].x)
|
|
|
std::swap(vertices[2], vertices[3]);
|
|
|
|
|
|
return vertices;
|
|
|
}
|
|
|
|
|
|
std::vector<cv::Point> CheckUtil::getLargestContourROI(const cv::Mat &binaryImg, bool &found)
|
|
|
{
|
|
|
std::vector<std::vector<cv::Point>> contours;
|
|
|
std::vector<cv::Vec4i> hierarchy;
|
|
|
|
|
|
// 查找轮廓
|
|
|
cv::findContours(binaryImg.clone(), contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
|
|
|
|
|
|
found = false;
|
|
|
if (contours.empty())
|
|
|
{
|
|
|
return std::vector<cv::Point>(); // 返回空Point向量
|
|
|
}
|
|
|
|
|
|
// 找到面积最大的轮廓
|
|
|
double maxArea = 0;
|
|
|
int maxAreaIdx = -1;
|
|
|
for (size_t i = 0; i < contours.size(); i++)
|
|
|
{
|
|
|
double area = cv::contourArea(contours[i]);
|
|
|
if (area > maxArea)
|
|
|
{
|
|
|
maxArea = area;
|
|
|
maxAreaIdx = i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没有找到有效轮廓（比如所有轮廓面积都为0）
|
|
|
if (maxAreaIdx == -1 || maxArea <= 0)
|
|
|
{
|
|
|
return std::vector<cv::Point>();
|
|
|
}
|
|
|
|
|
|
found = true;
|
|
|
// 返回最大轮廓的边界矩形
|
|
|
return contours[maxAreaIdx];
|
|
|
}
|
|
|
|
|
|
std::string CheckUtil::GetRectString(cv::Rect rect)
|
|
|
{
|
|
|
std::string str = "[" + std::to_string(rect.x) + "," + std::to_string(rect.y) + "," + std::to_string(rect.width) + "," + std::to_string(rect.height) + "]";
|
|
|
return str;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::CreateDir(const std::string &dir)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
if (dir.empty())
|
|
|
return -1;
|
|
|
std::string pdir;
|
|
|
if ((ret = _sysmkdir_2(dir)) == -1)
|
|
|
{
|
|
|
pdir = __getParentDir_2(dir);
|
|
|
if ((ret = CreateDir(pdir)) == 0)
|
|
|
{
|
|
|
ret = CreateDir(dir);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
bool CheckUtil::bcalDis(cv::Point p1, cv::Point p2, int disT)
|
|
|
{
|
|
|
double dis = std::sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
|
|
|
if (dis < disT)
|
|
|
return true;
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
double CheckUtil::calDis(cv::Point p1, cv::Point p2)
|
|
|
{
|
|
|
double dis = std::sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
|
|
|
return dis;
|
|
|
}
|
|
|
|
|
|
void CheckUtil::PrintRect(cv::Rect roi, std::string str)
|
|
|
{
|
|
|
printf("%s x %d y %d w %d h %d \n", str.c_str(), roi.x, roi.y, roi.width, roi.height);
|
|
|
}
|
|
|
|
|
|
int CheckUtil::cutSmallImg(cv::Mat img, std::vector<cv::Rect> &samllRoiList, cv::Rect config_roi, int config_SmallImg_Width, int config_SmallImg_Height, int config_MinOverlap_Width, int config_MinOverlap_Height)
|
|
|
{
|
|
|
if (img.empty())
|
|
|
{
|
|
|
printf("error >>>> img.empty \n");
|
|
|
return 1;
|
|
|
/* code */
|
|
|
}
|
|
|
if (!RoiInImg(config_roi, img))
|
|
|
{
|
|
|
printf("error >>>> roi != img size \n");
|
|
|
return 2;
|
|
|
}
|
|
|
if (config_SmallImg_Width <= 0 ||
|
|
|
config_SmallImg_Height <= 0 ||
|
|
|
config_SmallImg_Width > img.cols ||
|
|
|
config_SmallImg_Height > img.rows)
|
|
|
{
|
|
|
printf("error >>>>config_SmallImg_Width %d config_SmallImg_Height %d \n ", config_SmallImg_Width, config_SmallImg_Height);
|
|
|
return 3;
|
|
|
}
|
|
|
if (config_MinOverlap_Width < 0 ||
|
|
|
config_MinOverlap_Height < 0 ||
|
|
|
config_MinOverlap_Width > img.cols ||
|
|
|
config_MinOverlap_Height > img.rows ||
|
|
|
config_MinOverlap_Width >= config_SmallImg_Width ||
|
|
|
config_MinOverlap_Height >= config_SmallImg_Height)
|
|
|
{
|
|
|
printf("error >>>>config_MinOverlap_Width %d config_MinOverlap_Height %d \n ", config_MinOverlap_Width, config_MinOverlap_Height);
|
|
|
return 4;
|
|
|
}
|
|
|
|
|
|
int AI_Img_width = config_SmallImg_Width;
|
|
|
int AI_Img_height = config_SmallImg_Height;
|
|
|
|
|
|
int start_x = config_roi.x;
|
|
|
int start_y = config_roi.y;
|
|
|
|
|
|
int end_x = config_roi.width + config_roi.x;
|
|
|
int end_y = config_roi.height + config_roi.y;
|
|
|
|
|
|
// 有效图片 宽 高
|
|
|
int det_width = config_roi.width;
|
|
|
int det_height = config_roi.height;
|
|
|
|
|
|
if (AI_Img_width > det_width || AI_Img_height > det_height)
|
|
|
{
|
|
|
printf("error >>>>config_SmallImg_Width %d != roi width %d \n ", config_SmallImg_Width, det_width);
|
|
|
printf("error >>>>config_SmallImg_Height %d != roi height %d \n ", config_SmallImg_Height, det_height);
|
|
|
return 5;
|
|
|
}
|
|
|
|
|
|
// printf("config_SmallImg_Width %d config_SmallImg_Height %d \n ", config_SmallImg_Width, config_SmallImg_Height);
|
|
|
// printf("config_MinOverlap_Width %d config_MinOverlap_Height %d \n ", config_MinOverlap_Width, config_MinOverlap_Height);
|
|
|
|
|
|
/////////////////、计算宽度方向 块的个数 和 重叠 ///////////////////////
|
|
|
// 可分为多少块 宽度度方向
|
|
|
float fBlocknum_x = det_width * 1.0f / AI_Img_width;
|
|
|
// 块的个数
|
|
|
int nBlocknum_x = std::ceil(fBlocknum_x);
|
|
|
|
|
|
// 如果 有重叠要求
|
|
|
if (config_MinOverlap_Width >= 0)
|
|
|
{
|
|
|
float fconfig_BlocknuNum_x = (det_width - AI_Img_width) * 1.0f / (config_SmallImg_Width - config_MinOverlap_Width) + 1;
|
|
|
int nconfig_BlocknuNum_x = std::ceil(fconfig_BlocknuNum_x);
|
|
|
if (nBlocknum_x < nconfig_BlocknuNum_x)
|
|
|
{
|
|
|
nBlocknum_x = nconfig_BlocknuNum_x;
|
|
|
}
|
|
|
}
|
|
|
int use_MinOverlap_Width = 0;
|
|
|
// 计算重叠率
|
|
|
if (nBlocknum_x > 1)
|
|
|
{
|
|
|
// 有多个块，要判断 块的重叠是否满足要求
|
|
|
int nSumLen_x = nBlocknum_x * AI_Img_width; //
|
|
|
float fOverlap_x = (nSumLen_x - det_width) * 1.0f / (nBlocknum_x - 1);
|
|
|
use_MinOverlap_Width = int(fOverlap_x);
|
|
|
}
|
|
|
// printf("nBlocknum_x %d use_MinOverlap_Width %d \n", nBlocknum_x, use_MinOverlap_Width);
|
|
|
|
|
|
/////////////////、计算高度方向 块的个数 和 重叠 ///////////////////////
|
|
|
// 可分为多少块 高度方向
|
|
|
float fBlocknum_y = det_height * 1.0f / AI_Img_height;
|
|
|
// 块的个数
|
|
|
int nBlocknum_y = std::ceil(fBlocknum_y);
|
|
|
|
|
|
// 如果 有重叠要求
|
|
|
if (config_MinOverlap_Height >= 0)
|
|
|
{
|
|
|
float fconfig_BlocknuNum_y = (det_height - AI_Img_height) * 1.0f / (config_SmallImg_Height - config_MinOverlap_Height) + 1;
|
|
|
int nconfig_BlocknuNum_y = std::ceil(fconfig_BlocknuNum_y);
|
|
|
if (nBlocknum_y < nconfig_BlocknuNum_y)
|
|
|
{
|
|
|
nBlocknum_y = nconfig_BlocknuNum_y;
|
|
|
}
|
|
|
}
|
|
|
int use_MinOverlap_Height = 0;
|
|
|
// 计算重叠率
|
|
|
if (nBlocknum_y > 1)
|
|
|
{
|
|
|
// 有多个块，要判断 块的重叠是否满足要求
|
|
|
int nSumLen_y = nBlocknum_y * AI_Img_height; //
|
|
|
float fOverlap_y = (nSumLen_y - det_height) * 1.0f / (nBlocknum_y - 1);
|
|
|
use_MinOverlap_Height = int(fOverlap_y);
|
|
|
}
|
|
|
|
|
|
// printf("nBlocknum_y %d use_MinOverlap_Height %d \n", nBlocknum_y, use_MinOverlap_Height);
|
|
|
|
|
|
int cut_sy = start_y;
|
|
|
int cut_ey = start_y + AI_Img_height;
|
|
|
|
|
|
for (int iy = 0; iy < nBlocknum_y; iy++)
|
|
|
{
|
|
|
int nleny = end_y - cut_ey;
|
|
|
|
|
|
int cut_sx = start_x;
|
|
|
int cut_ex = start_x + AI_Img_width;
|
|
|
for (int ix = 0; ix < nBlocknum_x; ix++)
|
|
|
{
|
|
|
|
|
|
cv::Rect roi;
|
|
|
roi.x = cut_sx;
|
|
|
roi.y = cut_sy;
|
|
|
roi.width = AI_Img_width;
|
|
|
roi.height = AI_Img_height;
|
|
|
|
|
|
samllRoiList.push_back(roi);
|
|
|
|
|
|
// 剩余长度
|
|
|
int nlenx = end_x - cut_ex;
|
|
|
if (nlenx > AI_Img_width)
|
|
|
{
|
|
|
cut_sx = cut_sx + AI_Img_width - use_MinOverlap_Width;
|
|
|
cut_ex = cut_sx + AI_Img_width;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cut_sx = end_x - AI_Img_width;
|
|
|
cut_ex = cut_sx + AI_Img_width;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (nleny > AI_Img_height)
|
|
|
{
|
|
|
cut_sy = cut_sy + AI_Img_height - use_MinOverlap_Height;
|
|
|
cut_ey = cut_sy + AI_Img_height;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cut_sy = end_y - AI_Img_height;
|
|
|
cut_ey = cut_sy + AI_Img_height;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
cv::Point2f CheckUtil::transformPoint(const cv::Point2f &point, const cv::Mat &transform_matrix)
|
|
|
{
|
|
|
// 验证变换矩阵有效性
|
|
|
if (transform_matrix.empty() || transform_matrix.rows != 2 || transform_matrix.cols != 3)
|
|
|
{
|
|
|
std::cerr << "Error: Invalid transformation matrix! Returning original point." << std::endl;
|
|
|
return point;
|
|
|
}
|
|
|
|
|
|
// 使用矩阵乘法进行点变换
|
|
|
cv::Mat point_mat = (cv::Mat_<double>(3, 1) << point.x, point.y, 1);
|
|
|
cv::Mat result_mat = transform_matrix * point_mat;
|
|
|
|
|
|
return cv::Point2f(result_mat.at<double>(0), result_mat.at<double>(1));
|
|
|
}
|
|
|
|
|
|
int CheckUtil::GetMaskProtrusions(const cv::Mat &binMask, std::vector<Mask_Protrusion_> &protrusions,
|
|
|
int nJumpThresh, int nMinRun, int nMinDepth, int nMaxRun)
|
|
|
{
|
|
|
protrusions.clear();
|
|
|
if (binMask.empty())
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
// 1、二值化（兼容 0/1 与 0/255 掩膜）
|
|
|
cv::Mat gray;
|
|
|
if (binMask.channels() != 1)
|
|
|
{
|
|
|
cv::cvtColor(binMask, gray, cv::COLOR_BGR2GRAY);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
gray = binMask;
|
|
|
}
|
|
|
cv::Mat maskFull;
|
|
|
cv::threshold(gray, maskFull, 0, 255, cv::THRESH_BINARY);
|
|
|
|
|
|
// 1.1 大掩膜先降采样再分析：凸起尺寸远大于降采样误差，可显著降低耗时
|
|
|
int nScale = 1;
|
|
|
while (nScale < 4 && std::max(maskFull.cols, maskFull.rows) / nScale > 2000)
|
|
|
{
|
|
|
nScale *= 2;
|
|
|
}
|
|
|
cv::Mat mask;
|
|
|
if (nScale > 1)
|
|
|
{
|
|
|
cv::resize(maskFull, mask, cv::Size(maskFull.cols / nScale, maskFull.rows / nScale), 0, 0, cv::INTER_NEAREST);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
mask = maskFull;
|
|
|
}
|
|
|
// 阈值按降采样比例换算到工作图尺度
|
|
|
nJumpThresh = std::max(2, nJumpThresh / nScale);
|
|
|
nMinRun = std::max(3, nMinRun / nScale);
|
|
|
nMinDepth = std::max(2, nMinDepth / nScale);
|
|
|
|
|
|
// 2、只保留最大连通域，避免背景杂物参与边界统计
|
|
|
cv::Mat labels, stats, centroids;
|
|
|
int nLabels = cv::connectedComponentsWithStats(mask, labels, stats, centroids, 8, CV_32S);
|
|
|
if (nLabels <= 1)
|
|
|
{
|
|
|
return 2;
|
|
|
}
|
|
|
int nMainIdx = 1;
|
|
|
int nMainArea = 0;
|
|
|
for (int i = 1; i < nLabels; i++)
|
|
|
{
|
|
|
int nArea = stats.at<int>(i, cv::CC_STAT_AREA);
|
|
|
if (nArea > nMainArea)
|
|
|
{
|
|
|
nMainArea = nArea;
|
|
|
nMainIdx = i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 3、裁剪到主体外接矩形，缩小后续扫描范围
|
|
|
cv::Rect boxMain(stats.at<int>(nMainIdx, cv::CC_STAT_LEFT), stats.at<int>(nMainIdx, cv::CC_STAT_TOP),
|
|
|
stats.at<int>(nMainIdx, cv::CC_STAT_WIDTH), stats.at<int>(nMainIdx, cv::CC_STAT_HEIGHT));
|
|
|
boxMain &= cv::Rect(0, 0, mask.cols, mask.rows);
|
|
|
if (boxMain.width <= 0 || boxMain.height <= 0)
|
|
|
{
|
|
|
return 2;
|
|
|
}
|
|
|
cv::Mat sub = (labels(boxMain) == nMainIdx); // 0/255
|
|
|
const int H = sub.rows;
|
|
|
const int W = sub.cols;
|
|
|
if (nMaxRun <= 0)
|
|
|
{
|
|
|
nMaxRun = std::max(100, std::min(H, W) / 3);
|
|
|
}
|
|
|
|
|
|
// 4、逐边抠凸起：
|
|
|
// 主体近似矩形，矩形边上的凸起会让该边的"边界值"先突变到外侧(进入凸起)、再突变回主体(离开凸起)；
|
|
|
// 区间内的边界值相对"首尾边界值线性插值"得到的基线持续外偏，即判定为一个凸起。
|
|
|
for (int nSide = 0; nSide < 4; nSide++)
|
|
|
{
|
|
|
const bool bRowScan = (nSide < 2); // 左右边按行扫描，上下边按列扫描
|
|
|
const int nLine = bRowScan ? H : W; // 扫描的行数/列数
|
|
|
const int nDir = (nSide == 0 || nSide == 2) ? 1 : -1; // 凸起内边界值变小(左侧/上侧)取 +1，变大取 -1
|
|
|
|
|
|
// 4.1 从每条 行/列 的外侧向内找第一个前景像素，得到该边的边界值 profile
|
|
|
std::vector<int> posList; // 有前景的行号/列号
|
|
|
std::vector<int> valList; // 对应的边界值
|
|
|
posList.reserve(nLine);
|
|
|
valList.reserve(nLine);
|
|
|
for (int i = 0; i < nLine; i++)
|
|
|
{
|
|
|
int nV = -1;
|
|
|
if (nSide == 0) // 左：自左向右
|
|
|
{
|
|
|
const uchar *p = sub.ptr<uchar>(i);
|
|
|
for (int x = 0; x < W; x++)
|
|
|
{
|
|
|
if (p[x])
|
|
|
{
|
|
|
nV = x;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (nSide == 1) // 右：自右向左
|
|
|
{
|
|
|
const uchar *p = sub.ptr<uchar>(i);
|
|
|
for (int x = W - 1; x >= 0; x--)
|
|
|
{
|
|
|
if (p[x])
|
|
|
{
|
|
|
nV = x;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (nSide == 2) // 上：自上向下
|
|
|
{
|
|
|
for (int y = 0; y < H; y++)
|
|
|
{
|
|
|
if (sub.ptr<uchar>(y)[i])
|
|
|
{
|
|
|
nV = y;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else // 下：自下向上
|
|
|
{
|
|
|
for (int y = H - 1; y >= 0; y--)
|
|
|
{
|
|
|
if (sub.ptr<uchar>(y)[i])
|
|
|
{
|
|
|
nV = y;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (nV >= 0)
|
|
|
{
|
|
|
posList.push_back(i);
|
|
|
valList.push_back(nV);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const int n = (int)valList.size();
|
|
|
if (n < nMinRun + 2)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 4.2 配对"进入/离开"突变，扣除该边上的凸起
|
|
|
int nUsedTo = -1; // 已统计过的凸起末端，避免同一个凸起重复输出
|
|
|
for (int s = 0; s + 1 < n; s++)
|
|
|
{
|
|
|
if (s <= nUsedTo)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
// 进入凸起：边界值朝外侧突变
|
|
|
if ((valList[s + 1] - valList[s]) * nDir >= -nJumpThresh)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
// 离开凸起：在其后 nMaxRun 范围内找第一个反向突变
|
|
|
int e = -1;
|
|
|
for (int j = s + nMinRun; j + 1 < n && j - s <= nMaxRun; j++)
|
|
|
{
|
|
|
if ((valList[j + 1] - valList[j]) * nDir > nJumpThresh)
|
|
|
{
|
|
|
e = j;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (e < 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 4.3 区间内的边界值应持续超出"首尾边界值线性插值"得到的基线
|
|
|
const int kk = e - s;
|
|
|
int nDevOk = 0;
|
|
|
float fMaxDev = 0.0f;
|
|
|
int nLow = valList[s + 1];
|
|
|
int nHigh = valList[s + 1];
|
|
|
for (int i = 1; i <= kk; i++)
|
|
|
{
|
|
|
float fBase = valList[s] + (valList[e + 1] - valList[s]) * (float)i / (float)(kk + 1);
|
|
|
float fDev = (fBase - valList[s + i]) * nDir;
|
|
|
fMaxDev = std::max(fMaxDev, fDev);
|
|
|
if (fDev >= nMinDepth)
|
|
|
{
|
|
|
nDevOk++;
|
|
|
}
|
|
|
nLow = std::min(nLow, valList[s + i]);
|
|
|
nHigh = std::max(nHigh, valList[s + i]);
|
|
|
}
|
|
|
if (fMaxDev < nMinDepth)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
// 凸起内大部分采样点都要明显外偏，避免把主体的斜边/圆角当成凸起
|
|
|
if (nDevOk < (int)(kk * 0.8f))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 4.4 计算凸起外接矩形（先算在 sub 图上的位置）
|
|
|
const int nLen = posList[e] - posList[s + 1] + 1; // 沿该边的长度
|
|
|
cv::Rect roiSub;
|
|
|
if (nSide == 0 || nSide == 2) // 左/上：外侧取小值，主体边缘取大值
|
|
|
{
|
|
|
int nOut = nLow;
|
|
|
int nInner = std::max(valList[s], valList[e + 1]);
|
|
|
if (nSide == 0)
|
|
|
{
|
|
|
roiSub = cv::Rect(nOut, posList[s + 1], nInner - nOut + 1, nLen);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
roiSub = cv::Rect(posList[s + 1], nOut, nLen, nInner - nOut + 1);
|
|
|
}
|
|
|
}
|
|
|
else // 右/下：外侧取大值，主体边缘取小值
|
|
|
{
|
|
|
int nOut = nHigh;
|
|
|
int nInner = std::min(valList[s], valList[e + 1]);
|
|
|
if (nSide == 1)
|
|
|
{
|
|
|
roiSub = cv::Rect(nInner, posList[s + 1], nOut - nInner + 1, nLen);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
roiSub = cv::Rect(posList[s + 1], nInner, nLen, nOut - nInner + 1);
|
|
|
}
|
|
|
}
|
|
|
roiSub &= cv::Rect(0, 0, W, H);
|
|
|
if (roiSub.width <= 0 || roiSub.height <= 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
Mask_Protrusion_ protr;
|
|
|
protr.nSide = nSide;
|
|
|
// 从工作图尺度还原到输入图尺度
|
|
|
protr.roi = cv::Rect((roiSub.x + boxMain.x) * nScale, (roiSub.y + boxMain.y) * nScale,
|
|
|
roiSub.width * nScale, roiSub.height * nScale);
|
|
|
protr.roi &= cv::Rect(0, 0, binMask.cols, binMask.rows);
|
|
|
if (protr.roi.width <= 0 || protr.roi.height <= 0)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
protr.fLen = (float)nLen * nScale;
|
|
|
protr.fDepth = fMaxDev * nScale;
|
|
|
int nMaskArea = cv::countNonZero(sub(roiSub));
|
|
|
protr.fArea = (float)nMaskArea * nScale * nScale;
|
|
|
protr.fFillRatio = (float)nMaskArea / (float)(roiSub.width * roiSub.height);
|
|
|
|
|
|
protrusions.push_back(protr);
|
|
|
nUsedTo = e; // 该凸起区间不再重复统计
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
} |
