|
|
/*
|
|
|
* 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"
|
|
|
#include <dirent.h>
|
|
|
#include <errno.h>
|
|
|
|
|
|
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;
|
|
|
}
|
|
|
static int _remove_dir_recursive_(const std::string &dir_path) {
|
|
|
DIR *dir = opendir(dir_path.c_str());
|
|
|
if (!dir) {
|
|
|
// 如果目录不存在，视为成功（因为目标是不存在）
|
|
|
if (errno == ENOENT) return 0;
|
|
|
printf("opendir[%s] error: %s\n", dir_path.c_str(), strerror(errno));
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
struct dirent *entry;
|
|
|
while ((entry = readdir(dir)) != nullptr) {
|
|
|
std::string name = entry->d_name;
|
|
|
// 跳过 . 和 ..
|
|
|
if (name == "." || name == "..") {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
std::string full_path = dir_path + "/" + name;
|
|
|
struct stat st;
|
|
|
|
|
|
// 获取文件状态，使用 lstat 以处理符号链接
|
|
|
if (lstat(full_path.c_str(), &st) == -1) {
|
|
|
printf("lstat[%s] error: %s\n", full_path.c_str(), strerror(errno));
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 如果是目录，递归删除
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
if (_remove_dir_recursive_(full_path) != 0) {
|
|
|
closedir(dir);
|
|
|
return -1;
|
|
|
}
|
|
|
// 删除空子目录
|
|
|
if (rmdir(full_path.c_str()) != 0) {
|
|
|
printf("rmdir[%s] error: %s\n", full_path.c_str(), strerror(errno));
|
|
|
closedir(dir);
|
|
|
return -1;
|
|
|
}
|
|
|
} else {
|
|
|
// 如果是文件（或符号链接等），直接删除
|
|
|
if (remove(full_path.c_str()) != 0) {
|
|
|
printf("remove[%s] error: %s\n", full_path.c_str(), strerror(errno));
|
|
|
closedir(dir);
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
closedir(dir);
|
|
|
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);
|
|
|
int nonZeroCount = cv::countNonZero(mask);
|
|
|
|
|
|
// printf("===========1== hj %f nonZeroCount %d\n", meanValue123[0], nonZeroCount);
|
|
|
|
|
|
if (nonZeroCount > 100)
|
|
|
{
|
|
|
cv::Mat element;
|
|
|
if (nonZeroCount > 1500)
|
|
|
{
|
|
|
element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(11, 11));
|
|
|
}
|
|
|
else if (nonZeroCount > 1000)
|
|
|
{
|
|
|
element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(7, 7));
|
|
|
}
|
|
|
else if (nonZeroCount > 500)
|
|
|
{
|
|
|
element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(5, 5));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
|
|
}
|
|
|
// 进行腐蚀操作
|
|
|
cv::Mat erodedMask;
|
|
|
cv::erode(mask, erodedMask, element);
|
|
|
int nonZeroCount111 = cv::countNonZero(erodedMask);
|
|
|
if (nonZeroCount111 > 100)
|
|
|
{
|
|
|
meanValue123 = cv::mean(absDiff, erodedMask);
|
|
|
// printf("========2===== hj %f nonZeroCount %d\n", meanValue123[0], nonZeroCount111);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// if (meanValue123[0] > 100)
|
|
|
// {
|
|
|
// // 打印 32F 像素值
|
|
|
// for (int i = 0; i < absDiff.rows; ++i)
|
|
|
// {
|
|
|
// for (int j = 0; j < absDiff.cols; ++j)
|
|
|
// {
|
|
|
// std::cout << "Pixel value at (" << i << ", " << j << "): "
|
|
|
// << absDiff.at<float>(i, j) << std::endl;
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
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];
|
|
|
}
|
|
|
|
|
|
float CheckUtil::CalRoi2RoiPre(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();
|
|
|
double iou = 0;
|
|
|
if (union_area != 0)
|
|
|
{
|
|
|
iou = intersection_area / union_area;
|
|
|
}
|
|
|
|
|
|
// 计算IoU值
|
|
|
|
|
|
return iou;
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
cv::Rect 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 cv::Rect(); // 返回空Rect
|
|
|
}
|
|
|
|
|
|
// 找到面积最大的轮廓
|
|
|
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 cv::Rect();
|
|
|
}
|
|
|
|
|
|
found = true;
|
|
|
// 返回最大轮廓的边界矩形
|
|
|
return cv::boundingRect(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;
|
|
|
}
|
|
|
|
|
|
int CheckUtil::DeleteDir(const std::string &dir)
|
|
|
{
|
|
|
if (dir.empty()) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 检查路径是否存在
|
|
|
struct stat st;
|
|
|
if (stat(dir.c_str(), &st) != 0) {
|
|
|
// 目录不存在，视为成功
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 如果不是目录，可能是文件，尝试直接删除
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
|
if (remove(dir.c_str()) == 0) {
|
|
|
return 0;
|
|
|
} else {
|
|
|
printf("remove file[%s] error: %s\n", dir.c_str(), strerror(errno));
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 是目录，先递归清空内容
|
|
|
if (_remove_dir_recursive_(dir) != 0) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 最后删除空目录本身
|
|
|
if (rmdir(dir.c_str()) != 0) {
|
|
|
printf("rmdir[%s] error: %s\n", dir.c_str(), strerror(errno));
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// printf("remove dir[%s] success.\n", dir.c_str());
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
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::Point2f p1, cv::Point2f 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));
|
|
|
} |
