装甲板识别个人实现

首先是main函数

#include <iostream>
#include <opencv2/opencv.hpp>
#include "ArmorPlate.h"

using namespace std;
using namespace cv;

bool CameraRead(ArmorPlate& armor_param);

int main()
{
	ArmorPlate armor;

	armor.CameraInit(0);

	//while (1)
	//{
		
		//if (!CameraRead(armor))
			//continue;
	
		armor.AutoShoot();

	//}
	return 0;
}

bool CameraRead(ArmorPlate& armor_param)
{
	armor_param.capture_plate.read(armor_param.armor_image);
	if (!armor_param.armor_image.data)
	{
		cout << "The camera has not read a image!" << endl;
		armor_param.CameraInit(0);
		return false;
	}
	else
		return true;
}

之后是头文件：

#pragma once

#define BLUETEAM 0
#define REDTEAM 1

class ArmorPlate
{
public:
	cv::Mat pre_image;
	cv::Mat armor_image;
	cv::VideoCapture capture_plate;

	int myteam;


	ArmorPlate();
	bool CameraInit(int device);
	void AutoShoot();

private:
	void ImgPreprosses(const cv::Mat& src, const cv::Mat& dst);


};


class ArmorRect
{
public:
	cv::RotatedRect armors;
};

之后就是CPP文件：

#include <opencv2/opencv.hpp>
#include "ArmorPlate.h"

using namespace std;
using namespace cv;


ArmorPlate::ArmorPlate()
{
	myteam = REDTEAM;
}

bool ArmorPlate::CameraInit(int device)
{
	capture_plate.open(device);
	if (!capture_plate.isOpened())
	{
		cout << "The capture has something wrong!";
		return false;
	}
	else return true;
}

cv::RotatedRect& adjustRec(cv::RotatedRect& rec)
{
	using std::swap;

	float& width = rec.size.width;
	float& height = rec.size.height;
	float& angle = rec.angle;


	while (angle >= 90.0) angle -= 180.0;
	while (angle < -90.0) angle += 180.0;

	
	
		if (angle >= 45.0)
		{
			swap(width, height);
			angle -= 90.0;
		}
		else if (angle < -45.0)
		{
			swap(width, height);
			angle += 90.0;
		}
	

	return rec;
}

void ArmorPlate::AutoShoot()
{
	armor_image = imread("2.jpg");
	ImgPreprosses(armor_image, pre_image);
	imshow("原图", armor_image);
	//imshow("预处理图", pre_image);
	waitKey(0);
}



void drawall(vector<RotatedRect> rec,Mat img)
{
	for (int i = 0; i < rec.size(); i++)
	{
		Point2f p[4];
		rec[i].points(p);
		line(img, p[0], p[1], Scalar(0, 0, 255), 1, 8, 0);
		line(img, p[1], p[2], Scalar(0, 0, 255), 1, 8, 0);
		line(img, p[2], p[3], Scalar(0, 0, 255), 1, 8, 0);
		line(img, p[3], p[0], Scalar(0, 0, 255), 1, 8, 0);
	}
}



void ArmorPlate::ImgPreprosses(const Mat& src, const Mat& dst)
{
	Mat grayImg;
	Mat binBrightImg;
	vector<RotatedRect> lightInfos;
	double MaxValue;
	vector<Mat> channels;
	//split(src, channels);
	//if (myteam == REDTEAM)
	//{
	//	grayImg = channels.at(0)- channels.at(2);
	//	blur(grayImg, grayImg, Size(3, 3));
	//	//grayImg *= 3;
	//}
	//else
	//	grayImg = channels.at(2) - channels.at(0);
	//imshow("灰度图",grayImg);
	//minMaxLoc(grayImg, 0, &MaxValue, 0, 0);waitKey(0);
	//threshold(grayImg, binBrightImg, MaxValue*0.85, 255, THRESH_BINARY);//THRESH_BINARY
	////CV_THRESH_OTSU不可用，因为该方法用于区分前景和后景

	//Mat element = getStructuringElement(MORPH_RECT,Size(3,3));

	//morphologyEx(binBrightImg, binBrightImg, MORPH_DILATE, element, Point(-1, -1), 1);
	////dilate(binBrightImg, binBrightImg, element);
	//morphologyEx(binBrightImg, binBrightImg, MORPH_OPEN, element,Point(-1,-1),3);
	////morphologyEx(binBrightImg, binBrightImg, MORPH_DILATE, element, Point(-1, -1), 1);
	//morphologyEx(binBrightImg, binBrightImg, MORPH_CLOSE, element, Point(-1, -1), 3);
	////medianBlur(binBrightImg, binBrightImg, 11);
	////dilate(binBrightImg, binBrightImg, element);
	//imshow("二值图", binBrightImg);waitKey(0);

	//方法2//
	Mat HSVImg;
	Mat image;
	cvtColor(src, HSVImg, COLOR_BGR2HSV);
	split(HSVImg, channels);
	minMaxLoc(channels[2], 0, &MaxValue, 0, 0); 
	threshold(channels[2], channels[2], MaxValue*0.98, 255, THRESH_BINARY);
	Mat element = getStructuringElement(MORPH_RECT, Size(5, 5));
	medianBlur(channels[2], channels[2], 3);
	morphologyEx(channels[2], channels[2], MORPH_DILATE, element, Point(-1, -1), 1);
	imshow("V通道二值图", channels[2]); waitKey();
	HSVImg.copyTo(image, channels[2]);
	int BLowH = 80;
	int BHighH = 150;
	int BLowS = 60;
	int BHighS = 255;
	int BLowV = 100;
	int BHighV = 255;
	//inRange(image, Scalar(BLowH, BLowS, BLowV), Scalar(BHighH, BHighS, BHighV), binBrightImg);
	//imshow("二值图", binBrightImg); waitKey(0);
	binBrightImg = channels[2];
	//方法2结束//

	vector<vector<Point>> lightContours;
	cv::findContours(binBrightImg.clone(), lightContours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
	Mat drawingImg = Mat::zeros(src.size(), CV_8UC3);
	for (int i = 0; i < lightContours.size(); i++)
		drawContours(drawingImg, lightContours, i, Scalar(0, 255, 0));
	imshow("轮廓图", drawingImg); waitKey(0);

	lightInfos.clear();

	for (const auto& contour : lightContours)
	{
		float lightContourArea = contourArea(contour);
		if (contour.size() <= 5 ||lightContourArea <10 ) continue;

		

		RotatedRect lightRec = fitEllipse(contour);
		RotatedRect minAreaRec = minAreaRect(contour);
		adjustRec(lightRec);
		if ((lightRec.size.width / lightRec.size.height) >0.8)
			continue;
		int x = lightRec.center.x - lightRec.size.width;
		if (x < 0)
			continue;
		int y = lightRec.center.y - lightRec.size.height;
		if (y < 0)
			continue;
		//cout << lightRec.angle << endl;
		//RotatedRect s;
		//s.angle = lightRec.angle;
		//s.center = lightRec.center;
		//if (minAreaRec.size.width > minAreaRec.size.height)
		//{
		//	s.size.height = minAreaRec.size.width;
		//	s.size.width = minAreaRec.size.height;
		//	//lightRec.angle += 90;
		//}
		//else
		//{
		//	s.size.height = minAreaRec.size.height;
		//	s.size.width = minAreaRec.size.width;
		//
		//}
		//
		//if (lightRec.size.width > lightRec.size.height)
		//{
		//	swap(lightRec.size.width, lightRec.size.height);
		//}

		if (lightRec.size.width / lightRec.size.height > 1.0 ||
			lightContourArea / lightRec.size.area() < 0.5)
			continue;
		lightRec.size.width *= 1.1;
		lightRec.size.height *= 1.1;

		Rect boundRect = lightRec.boundingRect();
		Mat lightImg = src(boundRect);

		if((lightRec.size.height>10&& (lightRec.size.height < 150)&&(lightRec.angle<45||lightRec.angle>135)))
			lightInfos.push_back(lightRec);


	}

	vector<RotatedRect> armors;
	vector<ArmorRect> armorRects;
	ArmorRect armorRect;

	armors.clear();
	armorRects.clear();

	if (lightInfos.size()<=1)
	{
		cout << "There's no light contours in quality." << endl;
	}
	
	sort(lightInfos.begin(), lightInfos.end(), [](const RotatedRect& ld1, const RotatedRect& ld2)
	{
		return ld1.center.x < ld2.center.x;
	});

	for (int i = 0; i < lightInfos.size(); i++)
	{
		for (int j = i + 1; j < lightInfos.size(); j++)
		{
			const RotatedRect& left = lightInfos[i];
			const RotatedRect& right = lightInfos[j];

			double heightDiff = abs(left.size.height - right.size.height);
			double widthDiff = abs(left.size.width - right.size.width);
			double angleDiff = abs(left.angle - right.angle);
			double yDiff = abs(left.center.y - right.center.y);
			double xDiff = abs(left.center.x - right.center.x);
			double meanheight = (left.size.height + right.size.height)/2;
			double yDiffRatio = yDiff / meanheight;
			double xDiffRatio = xDiff / meanheight;
			double dis= sqrt((left.center.x - right.center.x)*(left.center.x - right.center.x) + (left.center.y - right.center.y)*(left.center.y - right.center.y));
			double ratio = dis / meanheight;
			float heightDiff_ratio = heightDiff / max(left.size.height, right.size.height);

			if (angleDiff > 10 || xDiffRatio < 0.5 || yDiffRatio>0.7||ratio>3||ratio<1)
				continue;

			armorRect.armors.center.x = (left.center.x + right.center.x) / 2;
			armorRect.armors.center.y = (left.center.y + right.center.y) / 2;
			armorRect.armors.angle= (left.angle + right.angle) / 2;
			//cout << left.angle << endl;
			//armorRect.armors.angle = 0;
			if (180 - angleDiff < 3)
				armorRect.armors.angle += 90;
			armorRect.armors.size.height= (left.size.height + right.size.height) / 2;
			armorRect.armors.size.width = sqrt((left.center.x - right.center.x)*(left.center.x - right.center.x) + (left.center.y - right.center.y)*(left.center.y - right.center.y));

			double nL = armorRect.armors.size.height;
			double nW = armorRect.armors.size.width;
			if (nL < nW)
			{
				armorRect.armors.size.height = nL;
				armorRect.armors.size.width = nW;
			}
			else
			{
				armorRect.armors.size.height = nW;
				armorRect.armors.size.width = nL;
			}

			armorRects.emplace_back(armorRect);
			armors.push_back(armorRect.armors);
		}
	}
	if (armorRects.empty())
		cout << "There is no armor in quality!" << endl;
	
	drawall(armors, src);
	imshow("", src);
}

本来一开始在预处理时用的是RGB通道（注释部分），通过RB通道相减（或者带权重的RGB相减），但是效果不好：

由于预处理去噪填坑将255区的长宽差不够，受蓝色灯光的影响导致椭圆拟合的角度总是不够好，提高阈值和后面调参的效果也不佳。在最后换成了HSV通道的处理，最后在经过一系列的调参工作后，总算得到了还算不错的效果：