opencv应用海康案例-拍照并识别方框

最新推荐文章于 2023-12-18 14:57:47 发布
最新推荐文章于 2023-12-18 14:57:47 发布
阅读量1.2k 收藏 10
点赞数 2
分类专栏： C++基础以及案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43360707/article/details/106412961
版权

在这里插入图片描述
在这里插入图片描述
从图片识别到方框并且截取出来，以下是全部代码：

// hkOpenCVtest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <windows.h>
#include <opencv2\opencv.hpp>
#include <opencv2\highgui.hpp>
//#include <opencv\opencv.hpp>
#include <opencv2\imgproc.hpp>
#include <io.h>

#define  GREY  0
#define  COLOR 1
#pragma warning(disable : 4996)
using namespace std;
using namespace cv;

//#define  DEBUGP
//文件的路径，也可以使用cin自己指定，例如cin>>path
char * filePath = "D:\\workspace\\hkjpg\\002";

string outPutPath = "D:\\workspace\\hkjpg\\003";

std::map<int, std::set<int>> generateBorders(const std::vector<cv::Point> & vecPts)
{
	std::map<int, std::set<int>> borders;
	cv::Point tl(vecPts[0]), tr(vecPts[1]), bl(vecPts[2]), br(vecPts[3]);

	// tl to tr
	double K = double(tl.y - tr.y) / (tl.x - tr.x);
	for (int i = tl.x; i < tr.x; ++i)
		borders[i].insert(cvRound(-K*(tl.x - i) + tl.y));

	// tr to br
	if (tr.x != br.x)
	{
		K = double(tr.y - br.y) / (tr.x - br.x);
		for (int i = tr.x; i < br.x; ++i)
			borders[i].insert(cvRound(-K*(tr.x - i) + tr.y));
	}

	// br to bl
	K = double(br.y - bl.y) / (br.x - bl.x);
	for (int i = bl.x; i < br.x; ++i)
		borders[i].insert(cvRound(-K*(br.x - i) + br.y));

	// bl to tl
	if (bl.x != tl.x)
	{
		K = double(bl.y - tl.y) / (bl.x - tl.x);
		for (int i = tl.x; i < bl.x; ++i)
			borders[i].insert(cvRound(-K*(bl.x - i) + bl.y));
	}

	for (auto it = borders.begin(); it != borders.end(); ++it)
	{
		if ((*it).second.size() == 2)
			continue;

		std::set<int> newone = { *(*it).second.begin(), *(--(*it).second.end()) };
		(*it).second.swap(newone);
	}

#ifdef DEBUG_CODE
	cv::Mat disp = cv::imread("1111.PNG", CV_LOAD_IMAGE_COLOR);

	for (auto it = borders.begin(); it != borders.end(); ++it)
	{
		cv::circle(disp, cv::Point((*it).first, *(*it).second.begin()), 1, cv::Scalar(255, 255, 0), -1);
		cv::circle(disp, cv::Point((*it).first, *(--(*it).second.end())), 1, cv::Scalar(0, 255, 255), -1);

	}

	cv::circle(disp, tl, 2, cv::Scalar(0, 0, 255), -1);
	cv::circle(disp, tr, 2, cv::Scalar(0, 0, 255), -1);
	cv::circle(disp, bl, 2, cv::Scalar(0, 0, 255), -1);
	cv::circle(disp, br, 2, cv::Scalar(0, 0, 255), -1);
#endif // DEBUG_CODE



	return borders;
}

cv::Mat generateMask(const cv::Mat & src, const std::vector<cv::Point> & vecPts)
{
	cv::Mat mask = cv::Mat::zeros(src.size(), CV_8UC1);

	cv::Point tl(vecPts[0]), tr(vecPts[1]), bl(vecPts[2]), br(vecPts[3]);
	std::map<int, std::set<int>> borders = generateBorders(vecPts);

	int minX = std::min(tl.x, bl.x),
		maxX = std::max(tr.x, br.x),
		minY = std::min(tl.y, tr.y),
		maxY = std::max(bl.y, br.y);

	uchar minZ = std::min(src.at<uchar>(tl), src.at<uchar>(tr));
	minZ = std::min(minZ, src.at<uchar>(bl));
	minZ = std::min(minZ, src.at<uchar>(br));


	for (size_t j = minY; j < maxY; ++j)
	{
		const uchar* pS = src.ptr<uchar>(j);
		uchar* pM = mask.ptr<uchar>(j);

		for (size_t i = minX; i < maxX; ++i)
		{
			// in the region.
			if (*borders[i].begin() < j && j < *(++borders[i].begin()))
			{
				pM[i] = pS[i];
			}
		}
	}
	return mask;

}

void rotate_arbitrarily_angle(Mat &src, Mat &dst, float angle)
{
	float radian = (float)(angle / 180.0 * CV_PI);

	//填充图像
	int maxBorder = (int)(max(src.cols, src.rows)* 1.414); //即为sqrt(2)*max
	int dx = (maxBorder - src.cols) / 2;
	int dy = (maxBorder - src.rows) / 2;
	copyMakeBorder(src, dst, dy, dy, dx, dx, BORDER_CONSTANT);

	//旋转
	Point2f center((float)(dst.cols / 2), (float)(dst.rows / 2));
	Mat affine_matrix = getRotationMatrix2D(center, angle, 1.0);//求得旋转矩阵
	warpAffine(dst, dst, affine_matrix, dst.size());

	//计算图像旋转之后包含图像的最大的矩形
	float sinVal = abs(sin(radian));
	float cosVal = abs(cos(radian));
	Size targetSize((int)(src.cols * cosVal + src.rows * sinVal),
		(int)(src.cols * sinVal + src.rows * cosVal));

	//剪掉多余边框
	int x = (dst.cols - targetSize.width) / 2;
	int y = (dst.rows - targetSize.height) / 2;
	Rect rect(x, y, targetSize.width, targetSize.height);
	dst = Mat(dst, rect);
}



// 获取指定像素点放射变换后的新的坐标位置
CvPoint getPointAffinedPos(CvPoint src, int h, int w, double degree)
{
	int diaLength = int(sqrt((h*h + w*w)));
	Point center;
	center.x = center.y = diaLength / 2;
	src.x += diaLength / 2 - w / 2;
	src.y += diaLength / 2 - h / 2;
	double angle = degree * CV_PI / 180.0;

	CvPoint dst;
	int x = src.x - center.x;
	int y = src.y - center.y;
	dst.x = cvRound(x * cos(angle) + y * sin(angle) + center.x);
	dst.y = cvRound(-x * sin(angle) + y * cos(angle) + center.y);
	return dst;
}
void GetImageRect(IplImage* orgImage, CvRect rectInImage, IplImage* imgRect)
{
	//从图像orgImage中提取一块（rectInImage）子图像imgRect
	IplImage *result = imgRect;
	CvSize size;
	size.width = rectInImage.width;
	size.height = rectInImage.height;
	//result=cvCreateImage( size, orgImage->depth, orgImage->nChannels );
	//从图像中提取子图像
	cvSetImageROI(orgImage, rectInImage);
	cvCopy(orgImage, result);
	cvResetImageROI(orgImage);
}

void getFiles(string path, vector<string>& files)
{
	//文件句柄  
	long long   hFile = 0;
	//文件信息  
	struct _finddata_t fileinfo;
	memset(&fileinfo, 0, sizeof(fileinfo));
	string p;
	if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
	{
		do
		{
			//如果是目录,迭代之  
			//如果不是,加入列表  
			if ((fileinfo.attrib &  _A_SUBDIR))
			{
				if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
					getFiles(p.assign(path).append("\\").append(fileinfo.name), files);
			}
			else
			{
				//如果是文件的化，放进来，这个加了路径名的path的命名
				files.push_back(p.assign(path).append("\\").append(fileinfo.name));
			}
			memset(&fileinfo, 0, sizeof(fileinfo));
		} while (_findnext(hFile, &fileinfo) == 0);
		_findclose(hFile);
	}
}

bool picSegment(Mat &ResizeImg, int type, int n, int threshhold = 1)
{
	Mat BinRGBImg;
	if (!type)
	{
		//灰度变换
		Mat gray;
		cvtColor(ResizeImg, gray, COLOR_BGR2GRAY);
		threshold(gray, BinRGBImg, 100, 255, THRESH_BINARY_INV);
#ifdef DEBUGP
		imshow("灰度阈值图", gray);
#endif
	}
	else
	{
		//基于颜色信息二值化
		unsigned char pixelB, pixelG, pixelR;  //记录各通道值
		unsigned char DifMax = 60;             //基于颜色区分的阈值设置
		unsigned char B = 25, G = 25, R = 25;

		if (1 == threshhold)
		{
			DifMax = 60;             //基于颜色区分的阈值设置
			B = 25;
			G = 25;
			R = 25; //各通道的阈值设定，
		}
		else if (2 == threshhold)
		{
			DifMax = 100;//基于颜色区分的阈值设置
			B = 40;
			G = 98;
			R = 8; //各通道的阈值设定，
		}



		BinRGBImg = ResizeImg.clone();  //二值化之后的图像
		for (int i = 0; i < ResizeImg.rows; i++)   //通过颜色分量将图片进行二值化处理
		{
			for (int j = 0; j < ResizeImg.cols; j++)
			{
				pixelB = ResizeImg.at<Vec3b>(i, j)[0]; //获取图片各个通道的值
				pixelG = ResizeImg.at<Vec3b>(i, j)[1];
				pixelR = ResizeImg.at<Vec3b>(i, j)[2];

				if (abs(pixelB - B) < DifMax && abs(pixelG - G) < DifMax && abs(pixelR - R) < DifMax)
				{                                           //将各个通道的值和各个通道阈值进行比较
					BinRGBImg.at<Vec3b>(i, j)[0] = 255;     //符合颜色阈值范围内的设置成白色
					BinRGBImg.at<Vec3b>(i, j)[1] = 255;
					BinRGBImg.at<Vec3b>(i, j)[2] = 255;
				}
				else
				{
					BinRGBImg.at<Vec3b>(i, j)[0] = 0;        //不符合颜色阈值范围内的设置为黑色
					BinRGBImg.at<Vec3b>(i, j)[1] = 0;
					BinRGBImg.at<Vec3b>(i, j)[2] = 0;
				}
			}
		}
#ifdef DEBUGP
		imshow("基于颜色信息二值化", BinRGBImg);        //显示二值化处理之后的图像
		cvWaitKey(0);
#endif
	}//

	//----------------------------
	Mat BinOriImg;     //形态学处理结果图像


	if (type)
	{
		Mat element = getStructuringElement(MORPH_RECT, Size(3, 3)); //设置形态学处理窗的大小
		dilate(BinRGBImg, BinOriImg, element);     //进行多次膨胀操作
		dilate(BinOriImg, BinOriImg, element);
		dilate(BinOriImg, BinOriImg, element);

		erode(BinOriImg, BinOriImg, element);      //进行多次腐蚀操作
		erode(BinOriImg, BinOriImg, element);
		erode(BinOriImg, BinOriImg, element);
#ifdef DEBUGP
		imshow("形态学处理后", BinOriImg);        //显示形态学处理之后的图像
		cvWaitKey(0);
#endif
		cvtColor(BinOriImg, BinOriImg, CV_BGR2GRAY);   //将形态学处理之后的图像转化为灰度图像
		threshold(BinOriImg, BinOriImg, 100, 255, THRESH_BINARY); //灰度图像二值化
	}
	else
	{
		Mat element = getStructuringElement(MORPH_RECT, Size(3, 3)); //设置形态学处理窗的大小
		dilate(BinRGBImg, BinOriImg, element);     //进行多次膨胀操作
												   //dilate(BinOriImg, BinOriImg, element);
												   //dilate(BinOriImg, BinOriImg, element);

		erode(BinOriImg, BinOriImg, element);      //进行多次腐蚀操作
												   //erode(BinOriImg, BinOriImg, element);
												   //erode(BinOriImg, BinOriImg, element);
#ifdef DEBUGP
		imshow("形态学处理后", BinOriImg);        //显示形态学处理之后的图像
		cvWaitKey(0);
#endif
	}

	//--------------------------------------
	double length, area, rectArea;     //定义轮廓周长、面积、外界矩形面积
	double rectDegree = 0.0;           //矩形度=外界矩形面积/轮廓面积
	double long2Short = 0.0;           //体态比=长边/短边
	CvRect rect;           //外界矩形
	CvBox2D box, boxTemp;  //外接矩形
	CvPoint2D32f pt[4];    //矩形定点变量
	double axisLong = 0.0, axisShort = 0.0;        //矩形的长边和短边
	double axisLongTemp = 0.0, axisShortTemp = 0.0;//矩形的长边和短边
	double LengthTemp;     //中间变量
	float  angle = 0;      //记录车牌的倾斜角度
	float  angleTemp = 0;
	bool   TestPlantFlag = 0;  //车牌检测成功标志位



	CvMemStorage *storage = cvCreateMemStorage(0);
	CvSeq * seq = 0;     //创建一个序列,CvSeq本身就是一个可以增长的序列，不是固定的序列
	CvSeq * tempSeq = cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvSeq), sizeof(CvPoint), storage);
	int cnt = cvFindContours(&(IplImage(BinOriImg)), storage, &seq, sizeof(CvContour), CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
	//第一个参数是IplImage指针类型，将MAT强制转换为IplImage指针类型
	//返回轮廓的数目 
	//获取二值图像中轮廓的个数
	cout << "number of contours   " << cnt << endl;  //打印轮廓个数
	for (tempSeq = seq; tempSeq != NULL; tempSeq = tempSeq->h_next)
	{
		length = cvArcLength(tempSeq);       //获取轮廓周长
		area = cvContourArea(tempSeq);       //获取轮廓面积
		printf("周长=%f,面积=%f\n", length, area);
		//if ((area > 1500 && area < 8000) && (length > 100) && (length < 300))     //矩形区域面积大小判断
		if ((area > 5000 && area < 8000) && (length < 500))
		{
			rect = cvBoundingRect(tempSeq, 1);//计算矩形边界
			boxTemp = cvMinAreaRect2(tempSeq, 0);  //获取轮廓的矩形
			cvBoxPoints(boxTemp, pt);              //获取矩形四个顶点坐标
			angleTemp = boxTemp.angle;                 //得到倾斜角度
			printf("x=%f,y=%f\n", pt[0].x, pt[0].y);
			//if ((pt[0].x > 200)&&((pt[0].x < 400)))
			{
				axisLongTemp = sqrt(pow(pt[1].x - pt[0].x, 2) + pow(pt[1].y - pt[0].y, 2));  //计算长轴（勾股定理）
				axisShortTemp = sqrt(pow(pt[2].x - pt[1].x, 2) + pow(pt[2].y - pt[1].y, 2)); //计算短轴（勾股定理）

				if (axisShortTemp > axisLongTemp)   //短轴大于长轴，交换数据
				{
					LengthTemp = axisLongTemp;
					axisLongTemp = axisShortTemp;
					axisShortTemp = LengthTemp;
				}
				else
					angleTemp += 90;

				rectArea = axisLongTemp * axisShortTemp;  //计算矩形的面积
				rectDegree = area / rectArea;     //计算矩形度（比值越接近1说明越接近矩形）

				long2Short = axisLongTemp / axisShortTemp; //计算长宽比
														   //if (long2Short > 2.2 && long2Short < 3.8 && rectDegree > 0.63 && rectDegree < 1.37 && rectArea > 2000 && rectArea < 50000)
				{
					Mat GuiRGBImg = ResizeImg.clone();
					TestPlantFlag = true;             //检测车牌区域成功
					for (int i = 0; i < 4; ++i)       //划线框出车牌区域
						cvLine(&(IplImage(GuiRGBImg)), cvPointFrom32f(pt[i]), cvPointFrom32f(pt[((i + 1) % 4) ? (i + 1) : 0]), CV_RGB(255, 0, 0));
#ifdef DEBUGP
					imshow("提取结果图", GuiRGBImg);    //显示最终结果图
					cvWaitKey(0);
#endif

					Mat mask, dst,rot;
					vector<vector<Point>> contour;
					std::vector<cv::Point>  pts;

					mask = Mat::zeros(GuiRGBImg.size(), CV_8U);

					for (int i = 0; i < 4; ++i)
					{
						Point p;
						p.x = pt[i].x;
						p.y = pt[i].y;
						pts.push_back(p);
					}
					

					//Mat genMat = generateMask(GuiRGBImg, vecPts);
					contour.push_back(pts);

					drawContours(mask, contour, 0, Scalar::all(255), -1);
					GuiRGBImg.copyTo(dst, mask);

					rotate_arbitrarily_angle(dst, rot, angleTemp);
					/*imshow("mask", dst);
					cvWaitKey(0);*/

					//imshow("rot", rot);
					//cvWaitKey(0);

					/*CvPoint tmpPt;
					tmpPt.x = rect.x;
					tmpPt.y = rect.y;
					CvPoint topLeft = getPointAffinedPos(tmpPt, rect.height, rect.width, angleTemp);*/

					box = boxTemp;
					angle = angleTemp;
					axisLong = axisLongTemp;
					axisShort = axisShortTemp;
					cout << "倾斜角度：" << angle << endl;
					//Sleep(10 * 1000);
					//cv::destroyWindow("提取结果图");

					//Mat roi = GuiRGBImg(Rect(pt[1].x,  pt[1].y, pt[3].x - pt[1].x, pt[1].y - pt[0].y));
					int xmin = 2000;
					int ymin = 2000;
					int xmax = 0;
					int ymax = 0;
					int pos1 = 0;
					int pos2 = 0;
					int pos3 = 0;
					int pos4 = 0;

					for (int i = 0; i < 3; i++)
					{
						if (xmin > pt[i].x)
						{
							xmin = pt[i].x;
							pos1 = i;
						}
						if (xmax < pt[i].x)
						{
							xmax = pt[i].x;
							pos4 = i;
						}

					}

					for (int i = 0; i < 3; i++)
					{
						if (ymin > pt[i].y)
						{
							ymin = pt[i].y;
						}
						if (ymax < pt[i].y)
						{
							ymax = pt[i].y;
						}

					}
					//Mat roi = GuiRGBImg(Rect(pt[1].x, pt[1].y, 85, 70));topLeft
					Mat roi = GuiRGBImg(Rect(xmin , ymin , 85, 70));
					//Mat roi = GuiRGBImg(Rect(xmin, ymin, xmax-xmin, ymax-ymin));
					//提取的关键就是Rect(0,0,30,30)，其中0 ，0表示感兴趣区域的左上角位置，后面的30,30表示感兴趣部分的宽度和高度
					Mat img1;
					roi.copyTo(img1);//将感兴趣区域赋值到img1；

					Mat ResizeImg, RotationImg;
					Point2f RPt(320, 320);

					resize(img1, ResizeImg, Size(640, 640 * img1.rows / img1.cols));

					rotate_arbitrarily_angle(ResizeImg, RotationImg, angle);

					Mat sc1, dc2;
					//cvCopy(&sc1,&dc2, &boxTemp);
					//GetImageRect(IplImage* orgImage, CvRect rectInImage, IplImage* imgRect)
#ifdef DEBUGP
					/*imshow("cvCopy", dc2);
					cvWaitKey(0);*/
#endif
					//RotationImg = getRotationMatrix2D(RPt, angle, 1);
#ifdef DEBUGP
					/*imshow("getRotationMatrix2D", RotationImg);
					cvWaitKey(0);*/
#endif
					//定义保存图像的完整路径
					char strSaveName[20] = { 0 };
					sprintf(strSaveName, "0000%d", n);
					string strImgSavePath = outPutPath + "\\" + strSaveName;
					//定义保存图像的格式
					strImgSavePath += ".jpg";
					//strImgSavePath += ".png";

					//保存操作
					imwrite(strImgSavePath.c_str(), RotationImg);

					//namedWindow("gag", 1);
#ifdef DEBUGP
					imshow("gag", ResizeImg);
					cvWaitKey(0);
#endif
					return true;
					//IplImage *image=NULL;
					将ROI区域图像保存在image中:左上角x、左上角y、矩形长、宽
					//cvSetImageROI(&(IplImage(GuiRGBImg)), cvRect(pt[0].x, pt[0].y, axisLong, axisShort));
					//cvShowImage("imageROI", &(IplImage(GuiRGBImg)));
					执行cvSetImageROI（）之后显示image图像是只显示ROI标识的一部分，即改变了指针image，
					但是它仍旧保留有原来图像的信息，在执行这一句cvResetImageROI(image),之后，image指示原来的图像信息。
					cvResetImageROI(image);
					cvShowImage("image2", image);
					//cvWaitKey(0);
				}
			}
		}
	}
	return false;
}





int main(int argc, const char * argv[])
{
	//string file_path;
	vector<string> files;
	getFiles(filePath, files);
	int size = files.size();


	for (int i = 0; i < size; i++)
	{
		string picname = files[i];
		Mat OriginalImg;
		OriginalImg = imread(picname, IMREAD_COLOR);//读取原始彩色图像
		//OriginalImg = imread("E:\\workspace\\1-MyWork\\2-巡逻机器人资料汇总\\src\\CH-HCNetSDKV6.1.4.6_build20191220_Win64\\hkOpencv\\hkOpenCVtest\\x64\\Release\\002.jpg", IMREAD_COLOR);//读取原始彩色图像
		if (OriginalImg.empty())  //判断图像对否读取成功
		{
			cout << "错误!读取图像失败\n";
			return -1;
		}
		//imshow("原图", OriginalImg); //显示原始图像
		//cvWaitKey(0);
		cout << "Width:" << OriginalImg.rows << "\tHeight:" << OriginalImg.cols << endl;//打印图像长宽


		Mat ResizeImg;
		if (OriginalImg.cols > 640)
			resize(OriginalImg, ResizeImg, Size(640, 640 * OriginalImg.rows / OriginalImg.cols));
		//imshow("尺寸变换图", ResizeImg);
		//cvWaitKey(0);

		if (!picSegment(ResizeImg, GREY, i, 0))
		{
			if (!picSegment(ResizeImg, COLOR, i, 1))
			{
				picSegment(ResizeImg, COLOR, i, 2);
			}
		}

		// insert code here...
		//Mat Imags = imread("D:\\workspace\\hkjpg\\002\\1590649791.jpg");//读取图片
		//imshow("source", Imags);//显示图片在 名为"source"的窗口里
		//Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));//获得用来腐蚀的内核矩阵
		//Mat Imags2;//用来存放腐蚀之后的图片
		//erode(Imags, Imags2, element);//进行腐蚀操作
		//imshow("target", Imags2);//显示图片 在名为"target"的窗口里
		//cvWaitKey(0);//等待按键操作再执行后续 按随意键将进行下一步 return 程序结束

	}//for
	return 0;
}

在这里插入图片描述
效果不是很好，准确率80%左右

泰勒朗斯
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ - opencv应用实例之矩形框检测
yohnyang的博客
01-02 3336
C++ - opencv应用实例之矩形框检测
OpenCvSharp (C# OpenCV) 形状检测与识别(附源码)
Color Space的博客
02-12 6204
基于OpenCV的图像形状检测(含源码)_Color Space的博客-CSDN博客导读本文给大家分享一个用OpenCV传统方法实现形状检测的小案例。背景介绍实例来源：https://github.com/akshaybhatia10/ComputerVision-Projects/tree/master/FindShapes其中典型的测试图片如下：上图中包含了矩
python鼠标点击图片，获取像素坐标
weixin_40469747的博客
09-10 1702
# coding: utf-8 import cv2 import numpy as np img = cv2.imread("E:\\workspace\\cvimg\\1.png") #print img.shape def on_EVENT_LBUTTONDOWN(event, x, y, flags, param): if event == cv2.EVENT_LBUTTONDOWN: xy = "%d,%d" % (x, y) print xy
Python Opencv 图片识别表格：边框线检测
努力让自己发光，对的人才能迎着光而来
05-14 9933
Python Opencv 图片识别表格：边框线检测
opencv4.8.0-opencv4.9.0-opencv-contrib4.8.0-opencv-contrib4.9.0
最新发布
05-15
了解并掌握OpenCV库的这两个版本，开发者可以利用其强大的功能来解决各种计算机视觉问题，如图像分类、物体检测、图像分割、3D重建、人脸识别等。同时，opencv_contrib的扩展功能为研究和开发带来了更多可能性，特别...
OpenCV 4.9.0 android sdk - 2024 年最新版
10-07
这是 OpenCV 4.9.0 版本的 Android SDK，适用于 Android 平台的开发者。OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和机器学习软件库，包含了超过2500种优化的算法。这个 SDK 包含了所有...
最新 OpenCV for Unity 2.5.7 - unity 人脸识别插件
11-13
Unity 的 OpenCV 是一个资源插件，可在 Unity 中使用 OpenCV 4.4.0。 官方网站 | 示例编码 | Android 演示 WebGL 演示 | 教程和演示视频 | 论坛 | API 引用 | 支持模块 | 免费试用版 功能： - 由于该资源包是 ...
opencv-基于opencv的手势识别-项目实战.zip
01-30
在本项目实战中，我们将深入探索如何...通过这个项目，你将深入理解OpenCV在实际问题中的应用，并掌握手势识别的关键技术和流程。同时，你也将有机会实践如何结合理论知识解决实际问题，提升你的编程和项目实施能力。
OpenCV 4.8.0 Android SDK - 完整版
07-16
这是 OpenCV 4.8.0 版本的 Android SDK，适用于 Android 平台的开发者。OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和机器学习软件库，包含了超过2500种优化的算法。这个 SDK 包含了所有...
opencv识别一张图片的多个红框，并截取红框的内容
weixin_73368873的博客
09-05 1012
需要获取图片的红框的内容。
Python opencv进行矩形识别
深圳五月花--老李的森林
02-23 5534
图像识别中，圆形和矩形识别是最常用的两种，本例讲解矩形识别，最后的结果是可以识别出圆心，4个顶点，如下图：左边是原始图像，右边是识别结果，在我i5 10400的CPU上，执行时间不到8ms。识别出结果后，计算任意3个顶点的彼此距离，共3个数据，其中数值最小值对应的2个顶点是短边，数值最大的2个顶点对应矩形的对角线，中间那个值的矩形的长边。如果是正方形，则最小值和中间值相等。知道了长边的2个点，也就很容易求得矩形的旋转方向，在机器人捡拾物品的过程中，也就知道了末端执行器的旋转角度值。
用python编程通过OpenCV框架检测矩形
weixin_46165286的博客
12-18 1278
用python编程通过OpenCV框架检测矩形
实现opencv在图片上画框准确定位某个主体
qq_63647674的博客
12-18 3801
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 本章主要讲述图片的缩小与放大，以及在图片上框出自己目标的东西 最后运用代码绘制自己的图画。 提示：以下是本篇文章正文内容，下面案例可供参考 一、如何导入库？ 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd impor
OpenCV批量识别并绘制多个方框
ltzg123的博客
10-23 1165
采用OpenSlide读入原始SVS文件，OpenCV批量匹配剪切的patch
使用Opencv进行轮廓检测，字符提取，简单的直方图字符识别！
热门推荐
17岁boy的博客
03-29 2万+
一.使用Opencv进行轮廓检测！所需函数：1.cvFindContours函数功能：从二值图像中检索轮廓，并返回检测到的轮廓的个数函数原型：int) cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour, int header_size = ...
智能图片裁剪框架。自动识别边框，手动调节选区，使用透视变换裁剪并矫正选区；适用于身份证，名片，文档等照片的裁剪
未来很长，但我会努力的走下去。
11-05 1万+
SmartCropper 项目地址：pqpo/SmartCropper  简介：
python opencv 人脸识别(第三部分：方框的绘制，实现人脸检测)
chatblanc的博客
04-27 1584
python opencv 人脸识别(第三部分：方框的绘制，实现人脸检测)
`pkg-config opencv --cflags --libs`
07-27
`pkg-config opencv --cflags --libs` 是一个用于获取 OpenCV 编译选项和链接选项的 pkg-config 命令。 `--cflags` 选项返回用于编译代码所需的选项，包括头文件路径和其他编译选项。 `--libs` 选项返回用于链接代码所需的选项，包括库文件路径和其他链接选项。 通过在终端中运行 `pkg-config opencv --cflags --libs` 命令，你可以获取适用于当前系统上已安装的 OpenCV 版本的编译和链接选项。这些选项可以用于确保在编译和链接项目时正确地包含和链接 OpenCV 库。 请注意，为了使用 `pkg-config` 命令，你需要在系统上安装了相应的 pkg-config 工具，并且已正确安装和配置了 OpenCV 库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值