[opencv][C++][车牌识别][切除车牌边框和钉子]车牌识别之分割字符,使用手机相机拍的图验证代码

最新推荐文章于 2023-02-13 14:51:26 发布
最新推荐文章于 2023-02-13 14:51:26 发布
阅读量462 收藏 7
点赞数 1
分类专栏： opencv c++ c 文章标签： opencv c++ 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41409403/article/details/118462090
版权
c++ 同时被 3 个专栏收录
12 篇文章 0 订阅
订阅专栏
c
12 篇文章 0 订阅
订阅专栏
opencv
5 篇文章 0 订阅
订阅专栏

此图只用于学习本文代码。
在这里插入图片描述
输出如下：

在这里插入图片描述

输出如下：
在这里插入图片描述

#include <iostream>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/imgproc/types_c.h>

#include <cmath>
#include <cstdlib>
using namespace std;
using namespace cv;
/*
	I:原图，完整车牌
	O:二值图，完整车牌
*/
int silmpleImgProcess(const cv::Mat& inputArray, cv::Mat& outputArray);
/*
	I:二值图，完整车牌
	O:二值图，被切掉边框的车牌
*/
int preCutAdjust(const cv::Mat& inputArray, cv::Mat& outputArray);
/*
	I:二值图，被切掉边框的车牌
	O:二值图，切出的字符拼成的车牌
*/
int cut(const cv::Mat& inputArray, cv::Mat& outputArray);
/*
	I:二值图，被切掉边框的车牌
	O:二值图，经过连通区域面积筛选后得到一张过滤网，bitwise_and实现(被切掉边框的车牌&过滤网)与操作。
*/
int findArea(const Mat inputArray, Mat& outputArray);

static int imfill(const Mat inputArray, Mat& outputArray);
static int cmpfunc(const void* a, const void* b);
static int delUpCol(cv::Mat& outputArray);
static int delDownCol(cv::Mat& outputArray);
static int delLeftRow(cv::Mat& outputArray);
static int delRightRow(cv::Mat& outputArray);
static int delRectRivet(const cv::Mat& inputArray, cv::Mat& outputArray);


int main()
{
	Mat img = imread("plate.jpg");

	Mat sip;	
	silmpleImgProcess(img, sip);

	Mat pca;
	preCutAdjust(sip, pca);

	Mat Area;
	findArea(pca, Area);

	Mat out;
	cut(Area, out);

	waitKey(0);
	return 0;
}

int imfill(const Mat inputArray, Mat& outputArray)
{
	Size m_Size = inputArray.size();
	Mat temimage = Mat::zeros(m_Size.height + 2, m_Size.width + 2, inputArray.type());

	inputArray.copyTo(temimage(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)));
	floodFill(temimage, Point(0, 0), Scalar(255));
	Mat cutImg;
	temimage(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)).copyTo(cutImg);
	outputArray = inputArray | (~cutImg);
	return 0;
}


//使用了张王李刘赵孙杨的文章中的代码https://blog.csdn.net/xuyangcao123/article/details/81023732
int findArea(const Mat inputArray, Mat& outputArray)
{
	Mat andArray;
	vector<vector<Point>>	contours;
	vector<Vec4i>			hierarchy;

	findContours(inputArray.clone(), contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);

	double max_area = 0;
	int index = 0;
	const int srcArea = inputArray.rows * inputArray.cols;
	const int srcAreaD512 = srcArea >> 9;

	andArray = Mat::zeros(inputArray.rows, inputArray.cols, inputArray.type());

	for (int i = 0; i < contours.size(); i++)
	{
		if (contourArea(contours[i]) > srcAreaD512)
		{
			drawContours(andArray, contours, i, Scalar(255));
			imfill(andArray, andArray);
		}
	}
	//imshow("andArray", andArray);
	//void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray());
	bitwise_and(inputArray, andArray, outputArray);
	//imshow("outputArray", outputArray);
	return 0;
}




int cmpfunc(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}

int dot2line(const cv::Mat& inputArray, const int (&pixArr)[1000],
	int &count,int (&posStart)[50], int (&posEnd)[50], int(&width)[50], int(&height)[50],int &sum)
{
	int col = inputArray.cols;
	int row = inputArray.rows;

	uchar pix;
	bool flage = false;
	for (int i = 0; i < col - 1; i++)
	{
		pix = pixArr[i];
		if (pix == 1 && !flage)
		{
			flage = true;
			posStart[count] = i;
			continue;
		}
		if (pix == 0 && flage)
		{
			flage = false;
			posEnd[count] = i;
			count++;
		}
		if (i == (col - 2) && flage)
		{
			flage = false;
			posEnd[count] = i;
			count++;
		}
	}

	// 记录所有字符宽度
	sum = 0;
	for (int i = 0; i < count; i++)
	{
		width[i] = posEnd[i] - posStart[i];
		sum += width[i];
	}


	//求出投影高度
	for (int k = 0; k < count; k++)
	{
		int cnt = 0;
		for (int i = 0; i < row - 1; i++)
		{
			for (int j = posStart[k]; j < posEnd[k]; j++)
			{
				pix = inputArray.at<uchar>(i, j);
				if (pix > 0)
				{
					cnt++;
					break;
				}
			}
		}
		height[k] = cnt;
	}


	return 0;
}


//去除上边框
int delUpCol(cv::Mat& outputArray)
{
	int roi_col = outputArray.cols;
	int roi_row = outputArray.rows;
	uchar pix;

	
	int planePixCnt = 0;
	int pixPlane[1000] = { 0 };//int pixPlane[img_delRR.cols];
	int posStart[50] = { 0 };
	int posEnd[50] = { 0 };
	int roi_width[50] = { 0 };
	int roi_height[50] = { 0 };
	int count = 0;
	int sum = 0;

	//产生投影数组
	for (int i = 0; i < roi_col - 1; i++)
	{
		for (int j = 0; j < roi_row - 1; j++)
		{
			pix = outputArray.at<uchar>(j, i);
			pixPlane[i] = 0;
			if (pix > 0)
			{
				pixPlane[i] = 1;//投影
				planePixCnt++;
				break;
			}
		}
	}

	//将连续的投影的起始终止坐标以及宽度记录到数组

	dot2line(outputArray,pixPlane, count, posStart, posEnd, roi_width, roi_height, sum);


	qsort(roi_width, count, sizeof(int), cmpfunc);
	int max_width = roi_width[count - 1];
	//
	//有效性判断
	bool validFlag = false;
	uchar validCnt = 0;
	const int widthD10 = roi_col / 10;
	const int heightD3M2 = (roi_row << 1) / 3;
	for (int i = count - 1; i >= 0; i--)
	{
		if (roi_width[i] >= widthD10 || roi_height[i] >= heightD3M2)
		{
			validCnt++;
		}
	}
	if (validCnt >= 7)
	{
		validFlag = true;
	}
	/
	//边缘
	int planePixCnt_border = 0;
	int pixPlane_border[1000] = { 0 };
	int posStart_border[50] = { 0 };
	int posEnd_border[50] = { 0 };
	int roi_width_border[50] = { 0 };
	int roi_height_border[50] = { 0 };
	int count_border = 0;
	int sum_border = 0;
	for (int i = 0; i < roi_col - 1; i++)
	{
		pix = outputArray.at<uchar>(0, i);
		if (pix > 0)
		{
			pixPlane_border[i] = 1;
			planePixCnt_border++;
		}
	}

	dot2line(outputArray,pixPlane_border, count_border, posStart_border, posEnd_border, roi_width_border,roi_height_border, sum_border);


	
	//短投影判断 && 短跳变判断
	//产生投影数组
	bool shortFlag = false;
	const int shortCmp = roi_col >> 3;
	for (int i = 0; i < roi_row - 1; i++)
	{
		int avrgCnt=0;
		for (int j = 0; j < roi_col - 1; j++)
		{
			pix = outputArray.at<uchar>(i, j);
			if (pix > 0)
			{
				avrgCnt++;
			}
		}
		if (avrgCnt <= shortCmp)
		{
			shortFlag = true;
			break;
		}
	}
	///

	
	const int up = (roi_col >> 3) * 7;
	const int halfCol = roi_col >> 1;
	if (false == validFlag || count < 7// || planePixCnt >= up  || sum < halfCol || max_width*7 > roi_col
		|| count_border < 7
		|| true == shortFlag)
	{
		cv::Rect m_select;
		m_select = Rect(0, 1, outputArray.cols, outputArray.rows - 1);
		Mat ROI = outputArray(m_select);
		outputArray = ROI;


		//imshow("outputArray", outputArray);
		//waitKey(0);

		delUpCol(outputArray);
	}
	/

	//waitKey(0);
	return 0;
}

//去除下边框
int delDownCol(cv::Mat& outputArray)
{

	int roi_col = outputArray.cols;
	int roi_row = outputArray.rows;
	uchar pix;

	
	int planePixCnt = 0;
	int pixPlane[1000] = { 0 };//int pixPlane[img_delRR.cols];
	int posStart[50] = { 0 };
	int posEnd[50] = { 0 };
	int roi_width[50] = { 0 };
	int roi_height[50] = { 0 };
	int count = 0;
	int sum = 0;

	//产生投影数组
	for (int i = 0; i < roi_col - 1; i++)
	{
		for (int j = 0; j < roi_row - 1; j++)
		{
			pix = outputArray.at<uchar>(j, i);
			pixPlane[i] = 0;
			if (pix > 0)
			{
				pixPlane[i] = 1;//投影
				planePixCnt++;
				break;
			}
		}
	}

	//将连续的投影的起始终止坐标以及宽度记录到数组

	dot2line(outputArray, pixPlane, count, posStart, posEnd, roi_width, roi_height, sum);


	qsort(roi_width, count, sizeof(int), cmpfunc);
	int max_width = roi_width[count - 1];
	//
	//有效性判断
	uchar validFlag = false;
	uchar validCnt = 0;
	const int widthD10 = roi_col / 10;
	const int heightD3M2 = (roi_row << 1) / 3;
	for (int i = count - 1; i >= 0; i--)
	{
		if (roi_width[i] >= widthD10 || roi_height[i] >= heightD3M2)
		{
			validCnt++;
		}
	}
	if (validCnt >= 7)
	{
		validFlag = true;
	}
	/
	//边缘
	int planePixCnt_border = 0;
	int pixPlane_border[1000] = { 0 };
	int posStart_border[50] = { 0 };
	int posEnd_border[50] = { 0 };
	int roi_width_border[50] = { 0 };
	int roi_height_border[50] = { 0 };
	int count_border = 0;
	int sum_border = 0;
	for (int i = 0; i < roi_col - 1; i++)
	{
		pix = outputArray.at<uchar>(roi_row-1, i);
		if (pix > 0)
		{
			pixPlane_border[i] = 1;
			planePixCnt_border++;
		}
	}

	dot2line(outputArray, pixPlane_border, count_border, posStart_border, posEnd_border, roi_width_border, roi_height_border, sum_border);

	
	//短投影判断 && 短跳变判断
	//产生投影数组
	bool shortFlag = false;
	const int shortCmp = roi_col >> 3;
	for (int i = roi_row - 1; i >= 0 ; i--)
	{
		int avrgCnt = 0;
		for (int j = 0; j < roi_col - 1; j++)
		{
			pix = outputArray.at<uchar>(i, j);
			if (pix > 0)
			{
				avrgCnt++;
			}
		}
		if (avrgCnt <= shortCmp)
		{
			shortFlag = true;
			break;
		}
	}
	///

	const int up = (roi_col >> 3) * 7;
	const int halfCol = roi_col >> 1;
	if (false == validFlag|| count < 7// || planePixCnt >= up  || sum < halfCol || max_width*7 > roi_col
		|| count_border < 7
		|| true == shortFlag)
	{
		cv::Rect m_select;
		m_select = Rect(0, 0, outputArray.cols, outputArray.rows - 1);
		Mat ROI = outputArray(m_select);
		outputArray = ROI;
		delDownCol(outputArray);
	}
	/

	//waitKey(0);
	return 0;
}


//去除左边框
int delLeftRow(cv::Mat& outputArray)
{
	int roi_col = outputArray.cols;
	int roi_row = outputArray.rows;
	uchar pix;
	int cnt = 0;
	for (int i = 0; i < roi_row - 1; i++)
	{
		for (int j = 0; j < roi_col - 1; j++)
		{
			pix = outputArray.at<uchar>(i, j);
			if (pix > 0)
			{
				cnt++;
				break;
			}
		}
	}
	int up = (roi_row >> 3) * 7;
	if (cnt >= up)
	{
		cv::Rect m_select;
		m_select = Rect(1, 0, outputArray.cols - 1, outputArray.rows);
		Mat ROI = outputArray(m_select);
		outputArray = ROI;
		delLeftRow(outputArray);
	}
	return 0;
}

//去除右边框
int delRightRow(cv::Mat& outputArray)
{
	int roi_col = outputArray.cols;
	int roi_row = outputArray.rows;
	uchar pix;
	int cnt = 0;
	for (int i = roi_row - 1; i > 0; i--)
	{
		for (int j = 0; j < roi_col - 1; j++)
		{
			pix = outputArray.at<uchar>(i, j);
			if (pix > 0)
			{
				cnt++;
				break;
			}
		}
	}
	int up = (roi_row >> 3) * 7;
	if (cnt >= up)
	{
		cv::Rect m_select;
		m_select = Rect(0, 0, outputArray.cols - 1, outputArray.rows);
		Mat ROI = outputArray(m_select);
		outputArray = ROI;
		delRightRow(outputArray);
	}
	return 0;
}

int delRectRivet(const cv::Mat& inputArray, cv::Mat& outputArray)
{
	outputArray = inputArray;
	cv::Rect m_select;

	
	m_select = Rect(0, 0, outputArray.cols, outputArray.rows >> 1);
	Mat UROI = outputArray(m_select);
	m_select = Rect(0, outputArray.rows >> 1, outputArray.cols, outputArray.rows - (outputArray.rows >> 1));
	Mat DROI = outputArray(m_select);

	delUpCol(UROI);
	//imshow("UROI", UROI);

	delDownCol(DROI);
	//imshow("DROI", DROI);

	//delUpRivet(UROI);
	//delDownRivet(DROI);

	Mat UD;
	vconcat(UROI, DROI, UD);
	outputArray = UD;

	//imshow("UD", UD);

	//
	//m_select = Rect(0, 0, outputArray.cols >> 1, outputArray.rows);
	//Mat LROI = outputArray(m_select);
	//m_select = Rect(outputArray.cols >> 1, 0, outputArray.cols - (outputArray.cols >> 1), outputArray.rows);
	//Mat RROI = outputArray(m_select);

	//delLeftRow(LROI);
	//delRightRow(RROI);

	//Mat LR;
	//hconcat(LROI, RROI, LR);
	//outputArray = LR;


	return 0;
}

int silmpleImgProcess(const cv::Mat& inputArray, cv::Mat& outputArray)
{
	outputArray = inputArray;
	Mat img = outputArray;
	Mat gray_img;
	// 生成灰度图像
	cvtColor(img, gray_img, CV_BGR2GRAY);
	//imshow("gray_img", gray_img);
	// 高斯模糊
	Mat img_gau;
	GaussianBlur(gray_img, img_gau, Size(3, 3), 0, 0);
	//imshow("img_gau", img_gau);
	// 阈值分割
	Mat img_threadhold;
	threshold(img_gau, img_threadhold, 0, 255, THRESH_BINARY + THRESH_OTSU);
	//imshow("img_threadhold", img_threadhold);

	outputArray = img_threadhold;
	return 0;
}

int preCutAdjust(const cv::Mat& inputArray, cv::Mat& outputArray)
{
	outputArray = inputArray;

	Mat img_delRR;
	delRectRivet(outputArray, img_delRR);
	outputArray = img_delRR;
	//imshow("img_delRR", img_delRR);
	//waitKey(0);
	//return 0;
	return 0;
}

int cut(const cv::Mat& inputArray, cv::Mat& outputArray)
{
	outputArray = inputArray;
	//切割边框&铆钉

	int roi_col = outputArray.cols;
	int roi_row = outputArray.rows;
	int count = 0;
	bool flage = false;
	int sum = 0;

	int posStart[50] = { 0 };
	int posEnd[50] = { 0 };
	int roi_width[50] = { 0 };
	int roi_height[50] = { 0 };
	int roi_width_cpy[50] = { 0 };
	int roi_height_cpy[50] = { 0 };

	uchar pix = 0;
	int pixPlane[1000] = { 0 };//int pixPlane[outputArray.cols];


	//产生投影数组
	for (int i = 0; i < roi_col - 1; i++)
	{
		for (int j = 0; j < roi_row - 1; j++)
		{
			pix = outputArray.at<uchar>(j, i);
			pixPlane[i] = 0;
			if (pix > 0)
			{
				pixPlane[i] = 1;//投影
				break;
			}
		}
	}

	if (1)
	{
		dot2line(outputArray, pixPlane, count, posStart, posEnd, roi_width, roi_height, sum);
	}
	else
	{
		//将连续的投影的起始终止坐标以及宽度记录到数组
		for (int i = 0; i < roi_col - 1; i++)
		{
			pix = pixPlane[i];
			if (pix == 1 && !flage)
			{
				flage = true;
				posStart[count] = i;
				continue;
			}
			if (pix == 0 && flage)
			{
				flage = false;
				posEnd[count] = i;
				count++;
			}
			if (i == (roi_col - 2) && flage)
			{
				flage = false;
				posEnd[count] = i;
				count++;
			}
		}

		// 记录所有字符宽度
		for (int n = 0; n < count; n++)
		{
			roi_width[n] = posEnd[n] - posStart[n];
		}

		//求出投影高度
		for (int k = 0; k < count; k++)
		{
			int cnt = 0;
			for (int i = 0; i < roi_row - 1; i++)
			{
				for (int j = posStart[k]; j < posEnd[k]; j++)
				{
					pix = outputArray.at<uchar>(i, j);
					if (pix > 0)
					{
						cnt++;
						break;
					}
				}
			}
			roi_height[k] = cnt;
		}
	}

	//

	//求出投影宽度的中位数
	memcpy(roi_width_cpy, roi_width, 50 * sizeof(int));
	qsort(roi_width_cpy, count, sizeof(int), cmpfunc);
	int median_width = roi_width_cpy[count >> 1];

	//求出投影高度的中位数
	memcpy(roi_height_cpy, roi_height, 50 * sizeof(int));
	qsort(roi_height_cpy, count, sizeof(int), cmpfunc);
	int median_height = roi_height_cpy[count >> 1];

	// 截取字符
	int outCnt = 0;
	Mat tmp, out;
	Mat number_img;
	//const int cmp_col = roi_col >> 3;//误差范围，自己定就行
	const int cmp_row = (roi_row * 3) >> 2;//误差范围，自己定就行
	for (int i = 0; i < count; i++)
	{
		//const int val_col = abs(roi_width[i] - median_width);
		//const int val_row = abs(roi_height[i] - median_height);
		//if (val_col < cmp_col && val_row < cmp_row)
		if (roi_height[i] > cmp_row)
		{
			Rect choose_rect(posStart[i], 0, roi_width[i], outputArray.rows);
			number_img = outputArray(choose_rect);

			imshow("number_img" + to_string(i), number_img);

			此处不了解怎么写比较好，干脆写成这样把，反正没多少个循环
			//if (0 == outCnt)
			//{
			//	tmp = number_img;
			//}
			//else
			//{
			//	hconcat(tmp, number_img, out);
			//	tmp = out;
			//}
			outCnt++;
		}
	}

	//	imshow("out", out);
	if (7 == outCnt)
	{
		cout << "stand" << endl;
	}
	else
	{
		cout << "outCnt == " << outCnt << "  non-stand!" << endl;
	}

	//waitKey(0);
	return 0;
}
/ycc
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EasyPR车牌检测 Java
qq_37659785的博客
05-13 215
近期处理项目中遇到车牌识别的需求， 最终选择使用EasyPR进行车牌检测 该部分包括：SVM训练、车号定位、车牌判断。
基于opencv2.4.9的车牌定位、倾斜校正、字符分割代码实现。含详细注解。
05-18
本人最近练手做的小项目，在CSDN上也参考了很多代码，积分花了不少可是大多都没用上！要么是版本不对劲，要么是完全读不懂，所以自己上传了！代码包括车牌定位，车牌倾斜校正，字符分割。字符的识别部分未做完。
车牌识别opencv_基于OpenCV 的车牌识别
weixin_39945679的博客
12-10 5713
车牌识别是一种图像处理技术，用于识别不同车辆。这项技术被广泛用于各种安全检测中。现在让我一起基于OpenCV编写Python代码来完成这一任务。车牌识别的相关步骤1.车牌检测：第一步是从汽车上检测车牌所在位置。我们将使用OpenCV中矩形的轮廓检测来寻找车牌。如果我们知道车牌的确切尺寸，颜色和大致位置，则可以提高准确性。通常，也会将根据摄像机的位置和该特定国家/地区所使用的车牌类型来训练检测算法。...
c# opencv车牌识别_车牌中的文字识别 OCR车牌识别
weixin_39963053的博客
11-17 1250
车牌识别在现实生活当中非常普遍：高速公路、停车系统、电子警察，甚至出现在车载设备上。它的工作原理大致这样：使用摄像头充当“眼睛”，使用openCV与深度学习充当“大脑”。实时车牌识别工作步骤：摄像头抓拍—>openCV初步定位车牌位置—>二次确认车牌位置的左右上下边界—>车牌倾斜校正—>车牌字符切割—>车牌字符识别。其中，车牌检测是车牌识别的前提条件和重要基础。安卓车...
OpenCV学习之路——车牌识别之车牌定位
weixin_30663471的博客
06-11 923
去年七月份因为学校项目需要开始接触图像处理，但那时候只是到网上找车牌识别代码，然后加入到自己的项目中，不太清楚细节原理。 现在自己重新一步步实现车牌识别。 ...
OpenCV实战（一）——简单的车牌识别
weixin_42358854的博客
03-02 568
原文地址https://blog.csdn.net/weixin_41695564/article/details/79712393
基于opencv的车牌识别解析与代码
热门推荐
LinJM-机器视觉
01-02 5万+
车牌识别太出名了，我也就花几天来了解下这个系统，并结合opencv进行实现。下面是一些介绍： 车辆牌照识别（License Plate Recognition，LPR）技术作为交通管理自动化的重要手段和车辆检测系统的一个重要环节，在交通监视和控制中占有很重要的地位。LPR系统可以广泛应用于高速公路电子收费站、出入控制、公路流量监控、失窃车辆查询、停车场车辆管理、公路稽查、检测黑牌机动车、监控违章车辆的电子警察等需要车牌认证的重要场合，尤其是基于车牌识别技术的高速公路收费系统中，相对于射频卡等技术，可以实现不
智能驾驶 车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》
AI吃大瓜的博客
02-01 4476
这是项目《智能驾驶 车牌检测和识别》系列之《C++实现车牌检测和识别（可实时车牌识别）》；本项目将开发一个C/C++版本的车牌检测和识别，其中车牌检测算法采用YOLOv5模型，车牌识别算法采用PlateNet模型；
OpenCV C++案例实战十《车牌号识别》
Zero___Chen的博客
12-19 3万+
OpenCV C++案例实战十《车牌号识别》前言一、车牌检测1.1.图像预处理1.2.轮廓提取1.3.功能效果1.4.功能源码二、字符切割2.1.图像预处理2.2.轮廓提取2.3.功能效果2.4.功能源码三、字符识别3.1.读取文件3.2.字符匹配3.3.功能源码四、效果显示五、源码总结 前言 本文将使用OpenCV C++ 进行车牌号识别。 一、车牌检测 原图如图所示。本案例的需求是进行车牌号码识别。所以，首先我们得定位车牌所在的位置，然后将车牌切割出来。接下来我们就来看看是如何实现。 1.1.图像预
用c++和opencv实现车牌识别
weixin_42584758的博客
02-13 1087
车牌识别是计算机视觉领域中的一个重要问题。使用 C 语言和 OpenCV 实现车牌识别可以分为以下几个步骤: 车牌定位: 使用 OpenCV 的图像处理功能, 对输入图像进行预处理, 找到图像中可能包含车牌的区域. 车牌分割: 对定位到的车牌区域进行分割, 将车牌分割成单个字符. 字符识别: 使用 OpenCV 的字符识别功能, 识别分割出的每个字符. 车牌识别: 将识别出的字符组合起来,...
OpenCV实现车牌字符分割(C++)
01-21
之前的车牌定位中已经获取到了车牌的位置，并且对车牌进行了提取。我们最终的目的是进行车牌识别，在这之前需要将字符进行分割，方便对每一个字符进行识别，最后将其拼接后便是完整的车牌号码。关于车牌定位可以看这篇文章： OpenCV车牌定位(C++) ，本文使用的图片也是来自这里。 先来看一看原图： 最左边的汉字本来是 沪，截取时只获得了右边一点点的部分，这与原图和获取方法都有关，对于 川、沪… 这一类左右分开的字会经常发生这类问题，对方法进行优化后可以解决，这里暂时不进行讨论。 后面的字都是完整的，字符分割的过程不会受影响。首先来一波常规操作，为了更方便处理，将其变成灰度图片： 分割的方法不止一种
基于Opencv的车牌分割c++源码
11-09
基于Opencv的车牌分割源码，用于Android 开发，使用jni调用c++,进行车牌分割，代码只有c++部分，在vs调试可用，需要配置opencv环境。
基于opencv的C++车牌识别
04-28
基于opencv的C++车牌识别，简单的识别系统。。。。。。。。。。。。
Python+OpenCV实现车牌字符分割和识别
09-20
主要为大家详细介绍了Python+OpenCV实现车牌字符分割和识别，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于C++和OpenCV的车牌识别搭建停车场管理系统项目源码.zip
最新发布
10-05
基于C++和OpenCV的车牌识别搭建停车场管理系统项目源码.zip已获导师指导并通过的97分高分课程大作业项目，代码完整下载可用。 基于C++和OpenCV的车牌识别搭建停车场管理系统项目源码.zip已获导师指导并通过的97分...
OpenCV+Python识别车牌和字符分割的实现
09-19
主要介绍了OpenCV+Python识别车牌和字符分割的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
基于OPENCV的智能车牌识别系统,基于opencv的车牌识别系统毕业设计,C,C++
09-10
基于opencv的车牌识别系统，原理，怎样实现详解，
[AT指令]ESP8266 连接 百度地图[IP普通定位] 接口，获取定位信息
weixin_41409403的博客
03-19 2145
1.连接一个能上网的wifi AT+CWJAP_CUR="TP-LINK_0141","password" 2.设置SSL的buf容量，照做就行 AT+CIPSSLSIZE=4096 3.TCP连接，你有兴趣也可以用SSL AT+CIPSTART="TCP","api.map.baidu.com",80 4.开启透传 AT+CIPMODE=1 5.发送GET请求 AT+CIPSEND 发出如下GET请求 GET /location/ip?ak=9oeRTAQ0OUATeR6a1XIBU1WvwIf
[opencv][C++][车牌识别][切除车牌边框和钉子]车牌识别之分割字符
weixin_41409403的博客
07-03 1207
这张车牌是一张网图。 opencv2最高版本opencv2.4.13.6 到了腐蚀膨胀这一步，结果如下图所示： 去除车牌的边框和钉子，结果如下图所示： 最后将识别到的图片拼起来，结果如下图所示：间距方面就不调了，能看就行 #include <iostream> #include <opencv2/highgui/highgui.hpp> #include <opencv2/imgproc.hpp> #include <opencv2/imgproc/type.
opencv C++车牌识别
05-05
车牌识别是计算机视觉领域中的一个重要应用之一，OpenCV是一个开源的计算机视觉库，它提供了很多图像处理和计算机视觉算法。下面是一个使用OpenCV实现车牌识别的简单步骤： 1.读取图像：使用OpenCV读取车牌图像。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值