directory

• Equalization code
• The template images are sorted by size
• The total code
• The test results
• New ideas

Since template matching is a comparison between pixels, the gray values of pixels under different lighting will be different. Therefore, before comparison, we need to carry out histogram equalization of the test graph and template graph, which can be achieved first. Batch processing will be used today to test the accuracy of template matching.

It is found that it is best to equalize all test diagrams before intercepting the template. It is not reasonable to equalize test diagrams and template diagrams separately. equalizeHist( src, dst ); This function only supports single channel equalization. For color images, multiple channels can be separated into a single channel and then combined into multiple channels.

Equalization code

for (int i = 0; i < filenames.size(a); i++) { srcImg = cv::imread(filenames[i]);
	/ / * * * * * * * * * * * * * * * * * * * * * * * * * for image processing part of the * * * * * * * * * * * * * * * * * * * * * * * * * * * /
	// Here we apply histogram equalization to the original image
	vector<Mat> channels;// Define the container for storage
	split(srcImg,channels);
	Mat bluechannel = channels[0];// The image of the b channel
	equalizeHist(bluechannel, bluechannel);/ / equalization
	Mat greenchannel = channels[1];// The image of the g channel
	equalizeHist(greenchannel, greenchannel);
	Mat redchannel = channels[2];// Image of r channel
	equalizeHist(redchannel, redchannel);
	merge(channels, dstImg);// Merge channels
	/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /
	savedfilename = dest + filenames[i].substr(len);
	std::cout << savedfilename << std::endl;
	cv::imwrite(savedfilename, dstImg);
	cout << "The first" << i << "Zhang Finish" << endl;
	waitKey(30);
}
Copy the code

The template images are sorted by size

The total code

#include <opencv2/opencv.hpp>
#include "opencv2/features2d.hpp"
#include <vector>
#include <algorithm>
#include <iostream>
#include "windows.h"
#include <stdio.h>
#include <time.h>
#include <math.h>  
#include <fstream>
#define WINDOW_NAME [Program window]			
using namespace cv;
using namespace std;

// Display the estimated and actual values
void show_text(int nums, String real_name)
{
	if (nums == 0)
	{
		cout << "Speculation: Big brown bottle."<<""<< real_name << endl;
	}
	else if (nums == 1)
	{
		cout << "Conjecture: BAL" << "" << real_name << endl;
	}
	else if (nums == 2)
	{
		cout << "Conjecture: Square bottom and rounded shoulders." << "" << real_name << endl;
	}
	else if (nums == 3)
	{
		cout << "Speculation: Strip" << "" << real_name << endl;
	}
	else if (nums == 4)
	{
		cout << "Speculation: Round shoulders" << "" << real_name << endl;
	}
	else if(nums == 5)
	{
		cout << "Speculation: Barrel shoulder." << "" << real_name << endl;
	}
	else if (nums == 6)
	{
		cout << "Speculation: Multifaceted shoulders." << "" << real_name << endl;
	}
	else if (nums == 7)
	{
		cout << "Speculation: Fang Fang" << "" << real_name << endl;
	}
	else if (nums == 8)
	{
		cout << "Speculations: Little strips." << "" << real_name << endl;
	}
	else if (nums == 9)
	{
		cout << "Speculation: Bucket shoulder." << "" << real_name << endl;
	}
	else if (nums == 10)
	{
		cout << "Speculation: Small square shoulders." << "" << real_name << endl;
	}
	else if (nums ==11)
	{
		cout << "Conjecture: grape-shaped" << "" << real_name << endl;
	}
	else if (nums == 12)
	{
		cout << "Speculation: A little strip." << "" << real_name << endl;
	}
	else 
	{
		cout << "Conjecture: None" << ""<< real_name << endl; }}// Show the likelihood that each template will best match the test diagram
void show_probability(int nums, double probability)
{
	if (nums == 0)
	{
		cout << "Probability of a big brown bottle." << "" << probability << endl;
	}
	else if (nums == 1)
	{
		cout << "Probability of BAL" << "" << probability << endl;
	}
	else if (nums == 2)
	{
		cout << "Probability of square bottom and round shoulders" << "" << probability << endl;
	}
	else if (nums == 3)
	{
		cout << "Probability of a strip" << "" << probability << endl;
	}
	else if (nums == 4)
	{
		cout << "Probability of round shoulders" << "" << probability << endl;
	}
	else if (nums == 5)
	{
		cout << "Probability of barrel shoulder" << "" << probability << endl;
	}
	else if (nums == 6)
	{
		cout << "Probability of multiple shoulders" << "" << probability << endl;
	}
	else if (nums == 7)
	{
		cout << "Probability of square" << "" << probability << endl;
	}
	else if (nums == 8)
	{
		cout << "Probability of a small bar" << "" << probability << endl;
	}
	else if (nums == 9)
	{
		cout << "Probability of bucket shoulder" << "" << probability << endl;
	}
	else if (nums == 10)
	{
		cout << "Probability of small square shoulders" << "" << probability << endl;
	}
	else if (nums == 11)
	{
		cout << "Probability of grape shape" << "" << probability << endl;
	}
	else if (nums == 12)
	{
		cout << "Probability of a small bar" << "" << probability << endl;
	}
	else
	{
		cout << "Probability of none" << ""<< probability << endl; }}/ / main program
int main(a)
{
	// Change the console font color
	system("color 02");
	/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * [0] the test folder path and templates folder path * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
	// Get the test folder path and template folder path
	cv::String path_test = "D:/opencv_picture_test/ visual project resize folder/test folder/equalization test map /";        
	cv::String path_template = "D:/opencv_picture_test/ visual project resize folder/template folder/equalization template/";    
	cout << "Address obtained successfully" << endl;
	/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 【 1 】 to load the template image * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
	// Create a template vector
	vector<Mat>tempMat;
	// Insert template elements
	Mat srcImage;
	std::vector<cv::String> temp_filenames;
	cv::glob(path_template, temp_filenames);                 // OpencV is a very useful function to read the file name in the specified path
	for (int i = 0; i < temp_filenames.size(a); i++) { srcImage = cv::imread(temp_filenames[i]);
		tempMat.push_back(srcImage);
	}
	// Get the number of templates
	int tempMat_Nums = tempMat.size(a);/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * (2) load testing image * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
	// Create a test vector
	vector<Mat>testMat;
	// Insert the test element
	std::vector<cv::String> test_filenames;
	cv::glob(path_test, test_filenames);                 // OpencV is a very useful function to read the file name in the specified path
	for (int i = 0; i < test_filenames.size(a); i++) { srcImage = cv::imread(test_filenames[i]);
		testMat.push_back(srcImage);
	}
	// Get the number of test graphs
	int testMat_Nums = testMat.size(a);/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * [3] for each test pattern template matching * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
	for (int j = 0; j < testMat_Nums; j++) { cout <<"The first"<< j <<"The test of a test picture."<< endl;
		Mat resultMat;
		Mat dispMat;
		int match_method = TM_CCORR_NORMED;		// This parameter is found to be good after trial and error.
		// Use each template to match the test graph and find the best match for each result, storing the value in the vector
		vector<double>goodval;
		vector<Point>goodlock;
		int matchnum = 0;
		Point matchLoc;
		for (int i = 0; i < tempMat_Nums; i++) {// The larger the positive value is, the higher the matching degree will be, and the larger the negative value will be, the greater the difference between the image will be. However, if the image has no obvious features (i.e. the pixel value in the image is close to the average value), the closer the returned value will be to 0.
			matchTemplate(testMat[j], tempMat[i], resultMat, match_method);
			// Do not normalize, because the best value after normalization of different templates is 1, which cannot be compared
			//normalize(resultMat, resultMat, 0, 1, NORM_MINMAX, -1, Mat()); / / normalization
			double minVal; double maxVal; Point minLoc; Point maxLoc;	// Define the maximum and minimum values and their position variables
			minMaxLoc(resultMat, &minVal, &maxVal, &minLoc, &maxLoc, Mat());	// Find the maximum and minimum matching values from the result matrix and determine their positions
			// For both methods SQDIFF and SQDIFF_NORMED, smaller values have higher matching results
			// For the rest of the method, the larger the value, the better the match
			if (match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED)
			{
				goodlock.push_back(minLoc);
				goodval.push_back(minVal);
			}
			else
			{
				goodlock.push_back(maxLoc);
				goodval.push_back(maxVal);
			}
			show_probability(i, maxVal);
			//cout << i << " " << maxVal << endl;
		}
		// Find the best group of goodval
		if (match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED)
		{
			auto goodPosition = min_element(goodval.begin(), goodval.end());
			matchnum = distance(begin(goodval), goodPosition);
		}
		else
		{
			auto goodPosition = max_element(goodval.begin(), goodval.end());
			matchnum = distance(begin(goodval), goodPosition);
		}
		show_text(matchnum, test_filenames[j]);
		matchLoc = goodlock[matchnum];
		testMat[j].copyTo(dispMat);
		// Draw a box of the same size as the template around the best match point
		rectangle(dispMat, matchLoc, Point(matchLoc.x + tempMat[matchnum].cols, matchLoc.y + tempMat[matchnum].rows), Scalar::all(0), 2.8.0);
		namedWindow("testMat", WINDOW_NORMAL);//WINDOW_NORMAL allows users to scale freely
		imshow("testMat", dispMat);
		waitKey(30);
	}
	return 0;
}
Copy the code

The test results

New ideas

The teacher said consider industrial cameras or use edge-based NCC template matching.