768 lines
25 KiB
C++
768 lines
25 KiB
C++
#include <HalconCpp.h>
|
|
#include <opencv.hpp>
|
|
#include <ios>
|
|
#include <handleAI.h>
|
|
#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));
|
|
static cv::Mat cutImg2Cls(std::vector<cv::Point> contour, cv::Mat imgInput, cv::Size targetSize = cv::Size(128, 128));
|
|
|
|
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;
|
|
}
|
|
|
|
int minSide = getMin(boundingBox.width, boundingBox.height);
|
|
if (minSide == 0) {
|
|
std::cerr << "Bounding box has zero width or height." << std::endl;
|
|
return result;
|
|
}
|
|
|
|
int splitCount = getMax(1, getMax(boundingBox.width, boundingBox.height) / minSide);
|
|
|
|
if (splitCount > 2) {
|
|
if (boundingBox.width > boundingBox.height) { // 横向裁
|
|
for (int i = 0; i < splitCount; i++) {
|
|
int x = boundingBox.x + boundingBox.height * i;
|
|
if (x + boundingBox.height > boundingBox.x + boundingBox.width)
|
|
break;
|
|
result.emplace_back(cutImg2Cls(cv::Rect(x, boundingBox.y, boundingBox.height, boundingBox.height), imgInput, targetSize));
|
|
}
|
|
// 确保最右边包含
|
|
result.emplace_back(cutImg2Cls(cv::Rect(boundingBox.x + boundingBox.width - boundingBox.height, boundingBox.y, boundingBox.height, boundingBox.height), imgInput, targetSize));
|
|
}
|
|
else { // 纵向裁
|
|
for (int i = 0; i < splitCount; i++) {
|
|
int y = boundingBox.y + boundingBox.width * i;
|
|
if (y + boundingBox.width > boundingBox.y + boundingBox.height)
|
|
break;
|
|
result.emplace_back(cutImg2Cls(cv::Rect(boundingBox.x, y, boundingBox.width, boundingBox.width), imgInput, targetSize));
|
|
}
|
|
result.emplace_back(cutImg2Cls(cv::Rect(boundingBox.x, boundingBox.y + boundingBox.height - boundingBox.width, boundingBox.width, boundingBox.width), imgInput, targetSize));
|
|
}
|
|
}
|
|
else {
|
|
result.emplace_back(cutImg2Cls(boundingBox, imgInput, targetSize));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static cv::Mat cutImg2Cls(std::vector<cv::Point> contour, cv::Mat imgInput, cv::Size targetSize)
|
|
{
|
|
if (contour.empty() || imgInput.empty()) {
|
|
std::cerr << "Empty contour or input image." << std::endl;
|
|
return cv::Mat();
|
|
}
|
|
|
|
cv::Rect boundingBox = cv::boundingRect(contour);
|
|
return cutImg2Cls(boundingBox, imgInput, targetSize);
|
|
}
|
|
|
|
static cv::Mat cutImg2Cls(cv::Rect boundingBox, cv::Mat imgInput, cv::Size targetSize)
|
|
{
|
|
if (boundingBox.width <= 0 || boundingBox.height <= 0 || imgInput.empty()) {
|
|
std::cerr << "Invalid bounding box or empty input image." << std::endl;
|
|
return cv::Mat();
|
|
}
|
|
|
|
cv::Point mid(boundingBox.x + boundingBox.width / 2, boundingBox.y + boundingBox.height / 2);
|
|
int sideLength = getMax(getMax(boundingBox.width, boundingBox.height), 128);
|
|
|
|
// 生成一个空的正方形黑图
|
|
cv::Mat squareImage(sideLength, sideLength, imgInput.type(), cv::Scalar(0, 0, 0));
|
|
|
|
// 从原图中取的期望矩形区域
|
|
cv::Rect expectRect(mid.x - sideLength / 2, mid.y - sideLength / 2, sideLength, sideLength);
|
|
|
|
int xOffset = 0;
|
|
int yOffset = 0;
|
|
|
|
// 调整 expectRect 防止越界
|
|
if (expectRect.x < 0) {
|
|
expectRect.width += expectRect.x;
|
|
xOffset -= expectRect.x;
|
|
expectRect.x = 0;
|
|
}
|
|
if (expectRect.y < 0) {
|
|
expectRect.height += expectRect.y;
|
|
yOffset -= expectRect.y;
|
|
expectRect.y = 0;
|
|
}
|
|
if (expectRect.x + expectRect.width > imgInput.cols)
|
|
expectRect.width = imgInput.cols - expectRect.x;
|
|
if (expectRect.y + expectRect.height > imgInput.rows)
|
|
expectRect.height = imgInput.rows - expectRect.y;
|
|
|
|
if (expectRect.width <= 0 || expectRect.height <= 0) {
|
|
std::cerr << "Adjusted region is invalid after clipping." << std::endl;
|
|
return cv::Mat();
|
|
}
|
|
|
|
imgInput(expectRect).copyTo(squareImage(cv::Rect(xOffset, yOffset, expectRect.width, expectRect.height)));
|
|
cv::resize(squareImage, squareImage, targetSize);
|
|
return squareImage;
|
|
}
|
|
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(getMax(rect1.x + rect1.width, rect2.x + rect2.width), getMax(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 = getMax(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 = getMax(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;
|
|
};
|