835 lines
27 KiB
C++
835 lines
27 KiB
C++
#include <HalconCpp.h>
|
||
#include <opencv.hpp>
|
||
#include <ios>
|
||
#include <algorithm>
|
||
#include <handleAI.h>
|
||
#include <QString>
|
||
#include <QByteArray>
|
||
#include <chrono>
|
||
#include <QTextCodec>
|
||
#pragma once
|
||
using namespace HalconCpp;
|
||
struct MatchResult {
|
||
cv::Rect boundingRect;
|
||
double confidence;
|
||
};
|
||
// 简单的图像相关算法
|
||
|
||
//融合两张图片白色区域
|
||
static cv::Mat mergeBinaryMats(const cv::Mat& mat1, const cv::Mat& mat2)
|
||
{
|
||
// 确保两个输入图像具有相同的尺寸
|
||
if (mat1.size() != mat2.size()) {
|
||
std::cerr << "Error: Input images must have the same size." << std::endl;
|
||
return cv::Mat();
|
||
}
|
||
|
||
// 创建一个输出图像，初始化为全黑
|
||
cv::Mat merged = cv::Mat::zeros(mat1.size(), CV_8U);
|
||
|
||
// 将两个输入图像中的白色部分合并到输出图像
|
||
cv::bitwise_or(mat1, mat2, merged);
|
||
|
||
return merged;
|
||
}
|
||
//Rect相加
|
||
static cv::Rect rectPlusRect(cv::Rect world, cv::Rect rect)
|
||
{
|
||
return cv::Rect(rect.x + world.x, rect.y + world.y, rect.width, rect.height);
|
||
}
|
||
static cv::Rect findMaxAreaContour(cv::Mat src)
|
||
{
|
||
int maxIndex = 0, maxArea = 0;
|
||
std::vector<std::vector<cv::Point>>contours;
|
||
cv::findContours(src, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
|
||
if (contours.size() == 0)
|
||
return cv::Rect(0, 0, 0, 0);
|
||
for (int i = 0; i < contours.size(); i++)
|
||
{
|
||
int Area = cv::contourArea(contours[i]);
|
||
if (Area > maxArea)
|
||
{
|
||
maxArea = Area;
|
||
maxIndex = i;
|
||
}
|
||
}
|
||
if (contours.size() != 0)
|
||
return cv::boundingRect(contours[maxIndex]);
|
||
return cv::Rect(0, 0, 0, 0);
|
||
}
|
||
static cv::Rect findMaxAreaContour(cv::Mat src, int& indexReturn)
|
||
{
|
||
int maxIndex = 0, maxArea = 0;
|
||
std::vector<std::vector<cv::Point>>contours;
|
||
cv::findContours(src, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
|
||
if (contours.size() == 0)
|
||
return cv::Rect(0, 0, 0, 0);
|
||
for (int i = 0; i < contours.size(); i++)
|
||
{
|
||
int Area = cv::contourArea(contours[i]);
|
||
if (Area > maxArea)
|
||
{
|
||
maxArea = Area;
|
||
maxIndex = i;
|
||
}
|
||
}
|
||
if (contours.size() != 0)
|
||
{
|
||
indexReturn = maxIndex;
|
||
return cv::boundingRect(contours[maxIndex]);
|
||
}
|
||
}
|
||
|
||
static cv::Mat cutImg2Cls(cv::Rect boundingBox, cv::Mat imgInput, cv::Size targetSize = cv::Size(128, 128))
|
||
{
|
||
if (boundingBox.width <= 0 || boundingBox.height <= 0 || imgInput.empty()) {
|
||
std::cerr << "Invalid bounding box or empty input image." << std::endl;
|
||
return cv::Mat();
|
||
}
|
||
|
||
// 以目标框中心为正方形中心，边长为 max(max(w,h),128)
|
||
const cv::Point mid(boundingBox.x + boundingBox.width / 2, boundingBox.y + boundingBox.height / 2);
|
||
const int sideLength = std::max(std::max(boundingBox.width, boundingBox.height), 128);
|
||
|
||
// 期望在原图上的 ROI（可能越界）
|
||
cv::Rect expectRect(mid.x - sideLength / 2, mid.y - sideLength / 2, sideLength, sideLength);
|
||
|
||
// 计算需要的边界填充（反射填充）
|
||
const int left = std::max(0, -expectRect.x);
|
||
const int top = std::max(0, -expectRect.y);
|
||
const int right = std::max(0, expectRect.x + expectRect.width - imgInput.cols);
|
||
const int bottom = std::max(0, expectRect.y + expectRect.height - imgInput.rows);
|
||
|
||
cv::Mat padded;
|
||
if (left || top || right || bottom) {
|
||
cv::copyMakeBorder(imgInput, padded, top, bottom, left, right, cv::BORDER_REFLECT_101);
|
||
} else {
|
||
padded = imgInput;
|
||
}
|
||
|
||
// 在填充后图像上的 ROI（保证不越界）
|
||
cv::Rect shifted(expectRect.x + left, expectRect.y + top, expectRect.width, expectRect.height);
|
||
|
||
// 最终裁剪并缩放
|
||
cv::Mat squareImage = padded(shifted).clone();
|
||
cv::resize(squareImage, squareImage, targetSize);
|
||
return squareImage;
|
||
}
|
||
|
||
static std::vector<cv::Mat> cutImg2ClsVec(cv::Rect boundingBox, cv::Mat imgInput, cv::Size targetSize = cv::Size(128, 128))
|
||
{
|
||
std::vector<cv::Mat> result;
|
||
|
||
if (boundingBox.width <= 0 || boundingBox.height <= 0 || imgInput.empty()) {
|
||
std::cerr << "Invalid bounding box or empty input image." << std::endl;
|
||
return result;
|
||
}
|
||
|
||
const int w = boundingBox.width;
|
||
const int h = boundingBox.height;
|
||
const int minSide = std::min(w, h);
|
||
if (minSide <= 0) {
|
||
std::cerr << "Bounding box has zero width or height." << std::endl;
|
||
return result;
|
||
}
|
||
|
||
// 沿长边切分为若干个 size=minSide 的方块，覆盖到末端且避免重复最后一块
|
||
const bool splitHoriz = (w > h); // 横向长 -> 沿X方向切
|
||
const int longSide = splitHoriz ? w : h;
|
||
const int step = minSide;
|
||
const int beginCoord = splitHoriz ? boundingBox.x : boundingBox.y;
|
||
const int endCoord = beginCoord + longSide;
|
||
|
||
// 计算切块起点列表
|
||
std::vector<int> starts;
|
||
starts.reserve((longSide + step - 1) / step);
|
||
for (int s = beginCoord; s + step <= endCoord; s += step) {
|
||
starts.emplace_back(s);
|
||
}
|
||
// 确保包含末端（避免遗漏），同时避免与最后一个重复
|
||
const int lastStart = endCoord - step;
|
||
if (starts.empty() || starts.back() != lastStart) {
|
||
starts.emplace_back(lastStart);
|
||
}
|
||
|
||
result.reserve(starts.size());
|
||
if (splitHoriz) {
|
||
for (int x : starts) {
|
||
result.emplace_back(cutImg2Cls(cv::Rect(x, boundingBox.y, minSide, minSide), imgInput, targetSize));
|
||
}
|
||
} else {
|
||
for (int y : starts) {
|
||
result.emplace_back(cutImg2Cls(cv::Rect(boundingBox.x, y, minSide, minSide), imgInput, targetSize));
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static cv::Mat HObject2Mat(HObject& Hobj) //HObject类型转Mat类型
|
||
{
|
||
HTuple htCh;
|
||
HString cType;
|
||
cv::Mat Image;
|
||
ConvertImageType(Hobj, &Hobj, "byte");
|
||
CountChannels(Hobj, &htCh);
|
||
Hlong wid = 0;
|
||
Hlong hgt = 0;
|
||
if (htCh[0].I() == 1)
|
||
{
|
||
HImage hImg(Hobj);
|
||
void* ptr = hImg.GetImagePointer1(&cType, &wid, &hgt);//GetImagePointer1(Hobj, &ptr, &cType, &wid, &hgt);
|
||
int W = wid;
|
||
int H = hgt;
|
||
Image.create(H, W, CV_8UC1);
|
||
unsigned char* pdata = static_cast<unsigned char*>(ptr);
|
||
memcpy(Image.data, pdata, W * H);
|
||
}
|
||
else if (htCh[0].I() == 3)
|
||
{
|
||
void* Rptr;
|
||
void* Gptr;
|
||
void* Bptr;
|
||
HImage hImg(Hobj);
|
||
hImg.GetImagePointer3(&Rptr, &Gptr, &Bptr, &cType, &wid, &hgt);
|
||
int W = wid;
|
||
int H = hgt;
|
||
Image.create(H, W, CV_8UC3);
|
||
std::vector<cv::Mat> VecM(3);
|
||
VecM[0].create(H, W, CV_8UC1);
|
||
VecM[1].create(H, W, CV_8UC1);
|
||
VecM[2].create(H, W, CV_8UC1);
|
||
unsigned char* R2 = (unsigned char*)Rptr;
|
||
unsigned char* G = (unsigned char*)Gptr;
|
||
unsigned char* B = (unsigned char*)Bptr;
|
||
memcpy(VecM[2].data, R2, W * H);
|
||
memcpy(VecM[1].data, G, W * H);
|
||
memcpy(VecM[0].data, B, W * H);
|
||
cv::merge(VecM, Image);
|
||
}
|
||
return Image;
|
||
}
|
||
enum MatsToHObjectEnum
|
||
{
|
||
horizontal,
|
||
vertical
|
||
};
|
||
static HalconCpp::HObject MatsToHObject(cv::Mat* img1, cv::Mat* img2, MatsToHObjectEnum type)
|
||
{
|
||
auto start3 = std::chrono::high_resolution_clock::now();
|
||
HalconCpp::HObject Hobj;
|
||
int height = 0;
|
||
int width = 0;
|
||
switch (type)
|
||
{
|
||
case horizontal:
|
||
width = img1->cols;
|
||
height = img1->rows + img2->rows;
|
||
break;
|
||
case vertical:
|
||
width = img1->cols + img2->cols;
|
||
height = img1->rows;
|
||
break;
|
||
}
|
||
if (img1->type() == CV_8UC1)
|
||
{
|
||
unsigned char* imgData = new unsigned char[width * height];
|
||
memcpy(imgData, img1->data, img1->rows * img1->cols);
|
||
memcpy(img1->rows * img1->cols + imgData, img2->data, img1->rows * img1->cols);
|
||
GenImage1(&Hobj, "byte", width, height, (Hlong)imgData);
|
||
delete[]imgData;
|
||
imgData = nullptr;
|
||
}
|
||
auto end3 = std::chrono::high_resolution_clock::now();
|
||
auto duration3 = std::chrono::duration_cast<std::chrono::milliseconds>(end3 - start3);
|
||
std::cout << "Time taken by functionxxx: " << duration3.count() << " milliseconds" << std::endl;
|
||
return Hobj;
|
||
}
|
||
static HalconCpp::HObject MatsToHObject(cv::Mat& img1, cv::Mat& img2, MatsToHObjectEnum type)
|
||
{
|
||
auto start3 = std::chrono::high_resolution_clock::now();
|
||
HalconCpp::HObject Hobj;
|
||
int height = 0;
|
||
int width = 0;
|
||
switch (type)
|
||
{
|
||
case horizontal:
|
||
width = img1.cols;
|
||
height = img1.rows + img2.rows;
|
||
break;
|
||
case vertical:
|
||
width = img1.cols + img2.cols;
|
||
height = img1.rows;
|
||
break;
|
||
}
|
||
if (img1.type() == CV_8UC1)
|
||
{
|
||
unsigned char* imgData = new unsigned char[width * height];
|
||
//#pragma omp parallel for
|
||
//for (int i = 0; i < 2; i++)
|
||
//{
|
||
// switch (i)
|
||
// {
|
||
// case 0:
|
||
// memcpy(imgData, img1.data, img1.rows * img1.cols);
|
||
// break;
|
||
// case 1:
|
||
// memcpy(img1.rows * img1.cols + imgData, img2.data, img1.rows * img1.cols);
|
||
// break;
|
||
// }
|
||
//}
|
||
memcpy(imgData, img1.data, img1.rows * img1.cols);
|
||
memcpy(img1.rows * img1.cols + imgData, img2.data, img1.rows * img1.cols);
|
||
GenImage1(&Hobj, "byte", width, height, (Hlong)imgData);
|
||
delete[]imgData;
|
||
imgData = nullptr;
|
||
}
|
||
auto end3 = std::chrono::high_resolution_clock::now();
|
||
auto duration3 = std::chrono::duration_cast<std::chrono::milliseconds>(end3 - start3);
|
||
std::cout << "Time taken by functionxxx: " << duration3.count() << " milliseconds" << std::endl;
|
||
return Hobj;
|
||
}
|
||
static void MatToHObjectV(cv::Mat& image, HalconCpp::HObject* Hobj)
|
||
{
|
||
int hgt = image.rows;
|
||
int wid = image.cols;
|
||
int i;
|
||
if (image.type() == CV_8UC3)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
std::vector<cv::Mat> imgchannel;
|
||
split(image, imgchannel);
|
||
cv::Mat imgB = imgchannel[0];
|
||
cv::Mat imgG = imgchannel[1];
|
||
cv::Mat imgR = imgchannel[2];
|
||
uchar* dataR = new uchar[hgt * wid];
|
||
uchar* dataG = new uchar[hgt * wid];
|
||
uchar* dataB = new uchar[hgt * wid];
|
||
for (i = 0; i < hgt; i++)
|
||
{
|
||
memcpy(dataR + wid * i, imgR.data + imgR.step * i, wid);
|
||
memcpy(dataG + wid * i, imgG.data + imgG.step * i, wid);
|
||
memcpy(dataB + wid * i, imgB.data + imgB.step * i, wid);
|
||
}
|
||
himage.GenImage3("byte", wid, hgt, dataR, dataG, dataB);
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPtR, * hImgPtG, * hImgPtB;
|
||
himage.GetImagePointer3(&hImgPtR, &hImgPtG, &hImgPtB, &tmpType, &tmpW, &tmpH);
|
||
|
||
GenImage3(Hobj, "byte", wid, hgt, (Hlong)hImgPtR, (Hlong)hImgPtG, (Hlong)hImgPtB);
|
||
delete[]dataR;
|
||
delete[]dataG;
|
||
delete[]dataB;
|
||
dataR = NULL;
|
||
dataG = NULL;
|
||
dataB = NULL;
|
||
}
|
||
else if (image.type() == CV_8UC1)
|
||
{
|
||
//HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
////uchar* data = new uchar[hgt * wid];
|
||
////for (i = 0; i < hgt; i++)
|
||
////{
|
||
//// memcpy(data + wid * i, image.data + image.step * i, wid);
|
||
////}
|
||
////gen_image_const
|
||
//himage.GenImage1("byte", wid, hgt, image.data);
|
||
|
||
//HalconCpp::HString tmpType;
|
||
//Hlong tmpW, tmpH;
|
||
//void* hImgPt;
|
||
//hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
//GenImage1(&Hobj, "byte", wid, hgt, (Hlong)hImgPt);
|
||
GenImage1(Hobj, "byte", wid, hgt, (Hlong)image.data);
|
||
|
||
/* delete[] data;
|
||
data = NULL;*/
|
||
|
||
}
|
||
else if (image.type() == CV_16UC1)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
ushort* data = new ushort[hgt * wid * 2];
|
||
|
||
memcpy(data, image.data, hgt * wid * 2);
|
||
|
||
|
||
himage.GenImage1("uint2", wid, hgt, data);
|
||
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPt;
|
||
hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
GenImage1(Hobj, "uint2", wid, hgt, (Hlong)hImgPt);
|
||
|
||
delete[] data;
|
||
data = NULL;
|
||
|
||
}
|
||
else if (image.type() == CV_16SC1)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
short* data = new short[hgt * wid * 2];
|
||
|
||
memcpy(data, image.data, hgt * wid * 2);
|
||
|
||
|
||
himage.GenImage1("int2", wid, hgt, data);
|
||
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPt;
|
||
hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
GenImage1(Hobj, "int2", wid, hgt, (Hlong)hImgPt);
|
||
|
||
delete[] data;
|
||
data = NULL;
|
||
|
||
}
|
||
|
||
}
|
||
static HalconCpp::HObject MatToHObject(cv::Mat& image)
|
||
{
|
||
HalconCpp::HObject Hobj;
|
||
int hgt = image.rows;
|
||
int wid = image.cols;
|
||
int i;
|
||
if (image.type() == CV_8UC3)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
std::vector<cv::Mat> imgchannel;
|
||
split(image, imgchannel);
|
||
cv::Mat imgB = imgchannel[0];
|
||
cv::Mat imgG = imgchannel[1];
|
||
cv::Mat imgR = imgchannel[2];
|
||
uchar* dataR = new uchar[hgt * wid];
|
||
uchar* dataG = new uchar[hgt * wid];
|
||
uchar* dataB = new uchar[hgt * wid];
|
||
for (i = 0; i < hgt; i++)
|
||
{
|
||
memcpy(dataR + wid * i, imgR.data + imgR.step * i, wid);
|
||
memcpy(dataG + wid * i, imgG.data + imgG.step * i, wid);
|
||
memcpy(dataB + wid * i, imgB.data + imgB.step * i, wid);
|
||
}
|
||
himage.GenImage3("byte", wid, hgt, dataR, dataG, dataB);
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPtR, * hImgPtG, * hImgPtB;
|
||
himage.GetImagePointer3(&hImgPtR, &hImgPtG, &hImgPtB, &tmpType, &tmpW, &tmpH);
|
||
|
||
GenImage3(&Hobj, "byte", wid, hgt, (Hlong)hImgPtR, (Hlong)hImgPtG, (Hlong)hImgPtB);
|
||
delete[]dataR;
|
||
delete[]dataG;
|
||
delete[]dataB;
|
||
dataR = NULL;
|
||
dataG = NULL;
|
||
dataB = NULL;
|
||
}
|
||
else if (image.type() == CV_8UC1)
|
||
{
|
||
//HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
////uchar* data = new uchar[hgt * wid];
|
||
////for (i = 0; i < hgt; i++)
|
||
////{
|
||
//// memcpy(data + wid * i, image.data + image.step * i, wid);
|
||
////}
|
||
////gen_image_const
|
||
//himage.GenImage1("byte", wid, hgt, image.data);
|
||
|
||
//HalconCpp::HString tmpType;
|
||
//Hlong tmpW, tmpH;
|
||
//void* hImgPt;
|
||
//hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
//GenImage1(&Hobj, "byte", wid, hgt, (Hlong)hImgPt);
|
||
GenImage1(&Hobj, "byte", wid, hgt, (Hlong)image.data);
|
||
|
||
/* delete[] data;
|
||
data = NULL;*/
|
||
|
||
}
|
||
else if (image.type() == CV_16UC1)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
ushort* data = new ushort[hgt * wid * 2];
|
||
|
||
memcpy(data, image.data, hgt * wid * 2);
|
||
|
||
|
||
himage.GenImage1("uint2", wid, hgt, data);
|
||
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPt;
|
||
hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
GenImage1(&Hobj, "uint2", wid, hgt, (Hlong)hImgPt);
|
||
|
||
delete[] data;
|
||
data = NULL;
|
||
|
||
}
|
||
else if (image.type() == CV_16SC1)
|
||
{
|
||
HalconCpp::HImage himage = HalconCpp::HImage();
|
||
|
||
short* data = new short[hgt * wid * 2];
|
||
|
||
memcpy(data, image.data, hgt * wid * 2);
|
||
|
||
|
||
himage.GenImage1("int2", wid, hgt, data);
|
||
|
||
HalconCpp::HString tmpType;
|
||
Hlong tmpW, tmpH;
|
||
void* hImgPt;
|
||
hImgPt = himage.GetImagePointer1(&tmpType, &tmpW, &tmpH);
|
||
GenImage1(&Hobj, "int2", wid, hgt, (Hlong)hImgPt);
|
||
|
||
delete[] data;
|
||
data = NULL;
|
||
|
||
}
|
||
|
||
return Hobj;
|
||
}
|
||
//获取两点之间的直线距离
|
||
static double getDistance(cv::Point pointO, cv::Point pointA)
|
||
{
|
||
double distance;
|
||
distance = powf((pointO.x - pointA.x), 2) + powf((pointO.y - pointA.y), 2);
|
||
distance = sqrtf(distance);
|
||
return distance;
|
||
}
|
||
//获取点到线段之间的直线距离
|
||
static double pointToLineDistance(const cv::Point& point, const cv::Point& lineStart, const cv::Point& lineEnd) {
|
||
double numerator = std::abs((lineEnd.y - lineStart.y) * point.x - (lineEnd.x - lineStart.x) * point.y + lineEnd.x * lineStart.y - lineEnd.y * lineStart.x);
|
||
double denominator = std::sqrt(std::pow(lineEnd.y - lineStart.y, 2) + std::pow(lineEnd.x - lineStart.x, 2));
|
||
return numerator / denominator;
|
||
}
|
||
//计算角度，pt2为顶点
|
||
static double calculateAngle(cv::Point pt1, cv::Point pt2, cv::Point pt3)
|
||
{
|
||
// 计算两个向量
|
||
cv::Point vector1 = pt1 - pt2;
|
||
cv::Point vector2 = pt3 - pt2;
|
||
|
||
// 计算两个向量的长度
|
||
double length1 = norm(vector1);
|
||
double length2 = norm(vector2);
|
||
|
||
// 计算两个向量的点积
|
||
double dotProduct = vector1.dot(vector2);
|
||
|
||
// 计算夹角的余弦值
|
||
double cosAngle = dotProduct / (length1 * length2);
|
||
|
||
// 计算夹角的弧度
|
||
double angleRadians = acos(cosAngle);
|
||
|
||
// 将弧度转换为度数
|
||
double angleDegrees = angleRadians * 180 / CV_PI;
|
||
|
||
return angleDegrees;
|
||
}
|
||
//计算角度偏移量，pt1,pt2为第一条线段，pt3,pt4为第二条线段
|
||
static double calculateAngleOffset(cv::Point pt11, cv::Point pt12, cv::Point pt21, cv::Point pt22)
|
||
{
|
||
// 计算第一条线段的向量
|
||
cv::Point vec1(pt12.x - pt11.x, pt12.y - pt11.y);
|
||
|
||
// 计算第二条线段的向量
|
||
cv::Point vec2(pt22.x - pt21.x, pt22.y - pt21.y);
|
||
|
||
// 计算向量的叉乘
|
||
double crossProduct = vec1.x * vec2.y - vec1.y * vec2.x;
|
||
|
||
// 计算角度偏移量
|
||
double angleOffset = atan2(crossProduct, vec1.dot(vec2));
|
||
|
||
// 将弧度转换为度数
|
||
angleOffset = angleOffset * 180 / CV_PI;
|
||
|
||
return angleOffset;
|
||
}
|
||
//通过角度计算圆上点的位置
|
||
static cv::Point calculatePointOnCircle(cv::Point center, double radius, double angleDegrees)
|
||
{
|
||
// 将角度转换为弧度
|
||
double angleRadians = angleDegrees * CV_PI / 180.0;
|
||
|
||
// 计算点的坐标
|
||
int x = static_cast<int>(center.x + radius * cos(angleRadians));
|
||
int y = static_cast<int>(center.y + radius * sin(angleRadians));
|
||
|
||
return cv::Point(x, y);
|
||
}
|
||
/// <summary>
|
||
/// 模板匹配，以MatchResult返回
|
||
/// </summary>
|
||
/// <param name="originalImage">图像</param>
|
||
/// <param name="templateImage">模板图像</param>
|
||
/// <returns></returns>
|
||
static MatchResult templateMatching(const cv::Mat& originalImage, const cv::Mat& templateImage) {
|
||
MatchResult result;
|
||
|
||
// 创建结果图像
|
||
int resultCols = originalImage.cols - templateImage.cols + 1;
|
||
int resultRows = originalImage.rows - templateImage.rows + 1;
|
||
cv::Mat resultImg(resultRows, resultCols, CV_32FC1);
|
||
|
||
// 进行模板匹配
|
||
cv::matchTemplate(originalImage, templateImage, resultImg, cv::TM_CCOEFF_NORMED);
|
||
|
||
// 归一化结果图像
|
||
cv::normalize(resultImg, resultImg, 0, 1, cv::NORM_MINMAX, -1, cv::Mat());
|
||
|
||
// 寻找最佳匹配位置
|
||
double minVal, maxVal;
|
||
cv::Point minLoc, maxLoc;
|
||
cv::minMaxLoc(resultImg, &minVal, &maxVal, &minLoc, &maxLoc);
|
||
|
||
// 设置矩形框和可信度
|
||
result.boundingRect = cv::Rect(maxLoc.x, maxLoc.y, templateImage.cols, templateImage.rows);
|
||
result.confidence = maxVal;
|
||
|
||
return result;
|
||
}
|
||
/// <summary>
|
||
/// 模板匹配,返回Rect以及分数
|
||
/// </summary>
|
||
/// <param name="templateImg">模板图像</param>
|
||
/// <param name="srcImg">匹配图像</param>
|
||
/// <param name="sorce">分数</param>
|
||
/// <returns></returns>
|
||
static cv::Rect doMatchTemplate(const cv::Mat& templateImg, const cv::Mat& srcImg, double* sorce)
|
||
{
|
||
cv::Mat resultImage;
|
||
matchTemplate(srcImg, templateImg, resultImage, cv::TM_CCOEFF_NORMED);
|
||
double minVal = 0, maxVal = 0;
|
||
cv::Point minLoc(0, 0), maxLoc(0, 0);
|
||
minMaxLoc(resultImage, &minVal, &maxVal, &minLoc, &maxLoc);
|
||
*sorce = maxVal;
|
||
cv::Rect rect(maxLoc.x, maxLoc.y, templateImg.cols, templateImg.rows);
|
||
return rect;
|
||
}
|
||
//计算contour是否重叠
|
||
static bool isContoursOverlap(const std::vector<cv::Point>& contour1, const std::vector<cv::Point>& contour2, double thresholdPercent = 0) {
|
||
cv::Rect rect1 = cv::boundingRect(contour1);
|
||
cv::Rect rect2 = cv::boundingRect(contour2);
|
||
cv::Size tempImgSize(std::max(rect1.x + rect1.width, rect2.x + rect2.width), std::max(rect1.y + rect1.height, rect2.y + rect2.height));
|
||
cv::Mat binaryImage = cv::Mat::zeros(tempImgSize, CV_8U);
|
||
|
||
// 画出目标轮廓
|
||
drawContours(binaryImage, std::vector<std::vector<cv::Point>>{contour2}, 0, cv::Scalar(255), -1);
|
||
|
||
double totalOverlap = 0.0;
|
||
|
||
|
||
// 创建一个临时的二值图像
|
||
cv::Mat tempBinaryImage = cv::Mat::zeros(tempImgSize, CV_8U);
|
||
// 画出当前轮廓
|
||
drawContours(tempBinaryImage, std::vector<std::vector<cv::Point>>{contour1}, 0, cv::Scalar(255), -1);
|
||
|
||
// 计算重叠的像素数
|
||
cv::Mat intersection = binaryImage & tempBinaryImage;
|
||
int overlapPixelCount = countNonZero(intersection);
|
||
|
||
// 计算当前轮廓的重叠百分比
|
||
double overlapPercentage = static_cast<double>(overlapPixelCount) / countNonZero(tempBinaryImage);
|
||
|
||
return overlapPercentage * 100.0 > thresholdPercent; // 将结果转换为百分比
|
||
}
|
||
//计算rect是否重叠
|
||
static bool isRectOverlap(const cv::Rect& rect1, const cv::Rect& rect2, double thresholdPercent = 0) {
|
||
// 计算两个矩形的重叠区域
|
||
cv::Rect intersection = rect1 & rect2;
|
||
if (thresholdPercent != 0)//如果有阈值
|
||
{
|
||
int maxCnotourArea = std::max(rect1.area(), rect2.area());
|
||
if (intersection.area() / maxCnotourArea < thresholdPercent)
|
||
return false;
|
||
}
|
||
// 如果重叠区域的面积大于0，则说明两个矩形重叠
|
||
return intersection.area() > 0;
|
||
}
|
||
//将两个contour的区域合并
|
||
static std::vector<cv::Point> contourPlusContour(const std::vector<cv::Point>& contour1, const std::vector<cv::Point>& contour2)
|
||
{
|
||
std::vector<cv::Point>res;
|
||
res.insert(res.end(), contour1.begin(), contour1.end());
|
||
res.insert(res.end(), contour2.begin(), contour2.end());
|
||
return res;
|
||
}
|
||
|
||
static cv::Rect BboxToRect(handdleAI::Bbox input)
|
||
{
|
||
return cv::Rect(input.x - input.w / 2, input.y - input.h / 2, input.w, input.h);
|
||
}
|
||
enum ngTypeEnum
|
||
{
|
||
OK,
|
||
huaHeng,
|
||
aoKeng,
|
||
zangWu
|
||
};
|
||
|
||
struct rectAndData
|
||
{
|
||
cv::Rect rect;
|
||
double defectHeight;
|
||
double defectWidth;
|
||
int badType = 0;
|
||
bool result;
|
||
ngTypeEnum ngType;
|
||
std::vector<cv::Point> contour;
|
||
rectAndData(cv::Rect rectInput, double defectHeightInput, double defectWidthInput, bool resultInput)
|
||
{
|
||
rect = rectInput;
|
||
defectHeight = defectHeightInput;
|
||
defectWidth = defectWidthInput;
|
||
result = resultInput;
|
||
}
|
||
rectAndData(cv::Rect rectInput, double defectHeightInput, double defectWidthInput, int n, bool resultInput)
|
||
{
|
||
rect = rectInput;
|
||
defectHeight = defectHeightInput;
|
||
defectWidth = defectWidthInput;
|
||
badType = n;
|
||
result = resultInput;
|
||
}
|
||
rectAndData(cv::Rect rectInput, double defectHeightInput, double defectWidthInput, int n, bool resultInput, std::vector<cv::Point>& contourInput)
|
||
{
|
||
rect = rectInput;
|
||
defectHeight = defectHeightInput;
|
||
defectWidth = defectWidthInput;
|
||
badType = n;
|
||
result = resultInput;
|
||
contour = contourInput;
|
||
}
|
||
rectAndData(cv::Rect rectInput, double defectHeightInput, double defectWidthInput, int n, bool resultInput, std::vector<cv::Point>& contourInput, ngTypeEnum inputNgType)
|
||
{
|
||
rect = rectInput;
|
||
defectHeight = defectHeightInput;
|
||
defectWidth = defectWidthInput;
|
||
badType = n;
|
||
result = resultInput;
|
||
contour = contourInput;
|
||
ngType = inputNgType;
|
||
}
|
||
};
|
||
;
|
||
//平铺图像
|
||
static cv::Mat tiledImages(std::vector<cv::Mat>& imgs)
|
||
{
|
||
if (imgs.size() == 0)
|
||
return cv::imread("./noimg.png",-1);
|
||
if (imgs.size() == 1)
|
||
return imgs[0];
|
||
for (auto& img : imgs)
|
||
{
|
||
if (img.channels() == 1)
|
||
cv::cvtColor(img, img, cv::COLOR_GRAY2BGR);
|
||
}
|
||
//总图像大小 平铺显示
|
||
int matWidth = 0, matHeight = 0;
|
||
for (auto& mat : imgs)
|
||
{
|
||
matHeight = std::max(mat.rows, matHeight);
|
||
matWidth += mat.cols;
|
||
}
|
||
cv::Mat showMat(matHeight, matWidth, CV_8UC3);
|
||
//平铺图像
|
||
int withCnt = 0;
|
||
for (auto& resultMat : imgs)
|
||
{
|
||
resultMat.copyTo(showMat(cv::Rect(withCnt, 0, resultMat.cols, resultMat.rows)));
|
||
withCnt += resultMat.cols;
|
||
}
|
||
return showMat;
|
||
};
|
||
|
||
/**
|
||
* 快速去噪函数
|
||
*
|
||
* 说明：
|
||
* - 优先使用均值滤波（box filter）实现快速平滑；
|
||
* - 对明显的椒盐噪声可开启中值滤波（按通道处理，适用于8U/16U）；
|
||
* - 指定较大核或需要可控平滑强度时，使用高斯滤波作为兜底。
|
||
*
|
||
* 参数：
|
||
* - inputMat 输入图像（支持单通道/多通道）；
|
||
* - outputMat 输出图像；
|
||
* - kernelSize 卷积核大小，必须为奇数且>=3（传偶数会自动+1）；
|
||
* - sigma 高斯滤波标准差，<=0 表示走OpenCV自动推导；
|
||
* - useMedian 是否启用中值滤波（更抗椒盐噪声，速度较均值略慢）。
|
||
*/
|
||
static void denoiseImage(const cv::Mat& inputMat, cv::Mat& outputMat, int kernelSize = 3, double sigma = 0.0, bool useMedian = false)
|
||
{
|
||
if (inputMat.empty()) {
|
||
outputMat.release();
|
||
return;
|
||
}
|
||
|
||
int k = kernelSize;
|
||
if (k < 3) k = 3; // 最小有效核大小
|
||
|
||
if ((k & 1) == 0) {
|
||
++k; // 转换为奇数核
|
||
}
|
||
|
||
// 快速路径（椒盐噪声）：启用中值滤波；多通道按通道分别处理
|
||
if (useMedian && (inputMat.depth() == CV_8U || inputMat.depth() == CV_16U)) {
|
||
if (inputMat.channels() == 1) {
|
||
cv::medianBlur(inputMat, outputMat, k);
|
||
return;
|
||
} else {
|
||
std::vector<cv::Mat> ch;
|
||
cv::split(inputMat, ch);
|
||
for (auto& c : ch) {
|
||
cv::medianBlur(c, c, k);
|
||
}
|
||
cv::merge(ch, outputMat);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 默认快速路径：小核且未指定sigma时使用均值滤波（分离实现，速度快）
|
||
if (k <= 5 && sigma <= 0.0) {
|
||
cv::blur(inputMat, outputMat, cv::Size(k, k), cv::Point(-1, -1), cv::BORDER_DEFAULT);
|
||
return;
|
||
}
|
||
|
||
// 兜底：使用可分离高斯滤波，适合较大核或需要指定平滑强度的场景
|
||
const double sigmaChecked = std::max(0.0, sigma);
|
||
cv::GaussianBlur(inputMat, outputMat, cv::Size(k, k), sigmaChecked, sigmaChecked, cv::BORDER_DEFAULT);
|
||
}
|
||
|
||
// 字符编码转换：GBK 编码的 std::string 转为 UTF-8 编码的 std::string（基于 Qt 5.14.x）
|
||
// 入参：gbkStr - GBK/GB2312/GB18030 字节序列（std::string 仅作为原始字节容器）
|
||
// 返回：UTF-8 编码的字节序列（std::string）
|
||
static inline std::string gbkToUtf8(const std::string& gbkStr)
|
||
{
|
||
// 使用 Qt 的 QTextCodec 进行编码转换
|
||
// 在 Windows 简体中文环境下，本地编码通常是 GBK/GB2312；此处显式指定 "GBK"
|
||
QTextCodec* codec = QTextCodec::codecForName("GBK");
|
||
if (!codec) {
|
||
// 兜底：如果没有 GBK codec（极少见），退化为直接当作本地 8-bit 解码
|
||
QString tmp = QString::fromLocal8Bit(gbkStr.data(), static_cast<int>(gbkStr.size()));
|
||
QByteArray utf8 = tmp.toUtf8();
|
||
return std::string(utf8.constData(), static_cast<size_t>(utf8.size()));
|
||
}
|
||
|
||
// 将 GBK 字节解码为 Unicode（QString）
|
||
QString unicode = codec->toUnicode(gbkStr.data(), static_cast<int>(gbkStr.size()));
|
||
// 再编码为 UTF-8
|
||
QByteArray utf8 = unicode.toUtf8();
|
||
return std::string(utf8.constData(), static_cast<size_t>(utf8.size()));
|
||
}
|