題目要求：在上一章OpenCV----簡單目標提取和分割中嘗試使用opencv連通性方法獲取了目標的面積和輪廓資訊，本章節將嘗試對這些特征進行整合，使用opencv中ml庫(machine learning)訓練一個目標分類器,給定一種輸入圖片，預測影像中目標的類別，
最新代碼庫已更新：opencv4_cpp
分析：
1）了解常用的分類模型，參見opencv ml API OpenCV namespace ml,首先建議一個簡單的SVM分類器，然后設計其他的分類器如樸素貝葉斯模型等；
2）設計命令列設定輸入圖片和模型選擇等，支持默認模型選擇；
3）考慮模板類進行分類模型選擇的通用能力；
4）支持模型引數手動設定；
5）進代碼設計成便于管理，解釋性強的工程，設計通用的工程模板；
-
檔案工程目錄
·bin ------------------生成可執行檔案目錄
·build ----------------檔案編譯的中間結果
·data -----------------訓練測驗資料（影像）
·include -------------頭檔案目錄和inline檔案（用于模板方法實作）
·lib --------------------用于生成頭檔案的lib檔案
·model --------------不同模型訓練生成的xml檔案
·src -------------------源檔案和源檔案編譯命令CMakeLists.txt
·CMakeLists.txt —外層檔案編譯命令
-
outer CMakeLists.txt
cmake_minimum_required (VERSION 3.0)
PROJECT(ch6)
set(CMAKE_BUILD_TYPE Release)
set(CMAKE_CXX_FLAGS "-std=c++17 -Wall")
set(CMAKE_CXX_FLAGS_RELEASE "-std=c++17 -O3 -fopenmp -pthread")
IF(EXISTS ${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
ENDIF()
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
include_directories(${PROJECT_SOURCE_DIR}/include)
link_directories(${PROJECT_SOURCE_DIR}/lib)
add_subdirectory(${PROJECT_SOURCE_DIR}/src)
- inner CMakeLists.txt
cmake_minimum_required (VERSION 3.0)
set(CMAKE_BUILD_TYPE Release)
set(CMAKE_CXX_FLAGS "-std=c++17 -Wall")
set(CMAKE_CXX_FLAGS_RELEASE "-std=c++17 -O3 -fopenmp -pthread")
include_directories(${PROJECT_SOURSE_DIR}/include)
# Requires OpenCV
find_package(OpenCV REQUIRED)
message("OpenCV version : ${OpenCV_VERSION}")
include_directories(${OpenCV_INCLUDE_DIRS})
link_directories(${OpenCV_LIB_DIR})
add_library(utils utils.cpp)
add_library(mwindow mwindow.cpp)
add_executable(main main.cpp)
target_link_libraries(main ${OpenCV_LIBS} utils mwindow -lopencv_ml)
- 結果演示
./bin/main data/test.pgm data/pattern.pgm bayes
./bin/main data/test.pgm data/pattern.pgm (svm)
./bin/main data/test.pgm data/pattern.pgm boost
- 代碼示例
1）更新之前的多視窗類MWindow Class
/*
@File :mwindow.hpp
@Description: :
@Date :2021/12/25 09:23:14
@Author :xieyin
@version :1.0
*/
#pragma once
#include<iostream>
#include<string>
#include<vector>
using namespace std;
#include<opencv2/core.hpp>
#include<opencv2/highgui.hpp>
using namespace cv;
class MWindow{
public:
// consturtor
MWindow(string windowTitle, int rows, int cols, int height=700, int width=1200, int flags=WINDOW_AUTOSIZE);
// add image into canvas
int addImage(string title, Mat img, bool render = false);
// remove image from canvas
void removeImage(int pos);
// adjust all image size in canvas
void render();
private:
string mWindowTitle;
int mRows;
int mCols;
Mat mCanvas;
vector<string> mSubTitles;
vector<Mat> mSubImages;
};
/*
@File :mwindow.cpp
@Description: :
@Date :2021/12/25 09:23:22
@Author :xieyin
@version :1.0
*/
#include<iostream>
#include<string>
#include<vector>
using namespace std;
#include<opencv2/core.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/opencv.hpp>
#include<opencv2/imgproc.hpp>
using namespace cv;
#include"mwindow.hpp"
MWindow::MWindow(string windowTitle, int rows, int cols, int height, int width, int flags):mWindowTitle(windowTitle), mRows(rows), mCols(cols){
/*
@description : MWindow constructor
@param :
windowTitle : whole window title
rows : sub window rows
cols : sub window cols
flags : namedWindow flags (eg, WINDOW_AUTOSIZE)
@Returns :
*/
// create canvas
namedWindow(mWindowTitle, flags);
mCanvas = Mat(height, width, CV_8UC3);
imshow(mWindowTitle, mCanvas);
}
int MWindow::addImage(string title, Mat img, bool render){
/*
@description : add title and image into canvas
@param :
title : sub image title
img : image to be added
render : render(flag) whether need to adjust the image for canvas
@Returns :
index : sub image index in total mRows * mCols
*/
int index=-1;
for(int i=0; i<mSubTitles.size(); i++){
string t=this->mSubTitles[i];
if(t.compare(title)==0){
index=i;
break;
}
}
if(index==-1){
mSubTitles.push_back(title);
mSubImages.push_back(img);
}else{
mSubImages[index]= img;
}
if(render){
MWindow::render();
}
return mSubImages.size() - 1;
}
void MWindow::removeImage(int pos){
/*
@description : remove image from canvas based on index
@param :
pos : sub image index in total mRows * mCols
@Returns :
None
*/
mSubTitles.erase(mSubTitles.begin() + pos);
mSubImages.erase(mSubImages.begin() + pos);
}
void MWindow::render(){
/*
@description : fill title and image into canvas in suitable way
@param :
None
@Returns :
None
*/
mCanvas.setTo(Scalar(20, 20, 20));
// get sub canvas size
int cellH = mCanvas.rows / mRows;
int cellW = mCanvas.cols / mCols;
// set total number of images to load
int n = mSubImages.size();
int numImgs = n > mRows * mCols ? mRows * mCols : n;
for(int i = 0; i < numImgs; i++){
// get title
string title = mSubTitles[i];
// get sub canvas top left location
int cellX = (cellW) * ((i) % mCols);
int cellY = (cellH) * floor( (i) / (float) mCols);
Rect mask(cellX, cellY, cellW, cellH);
// set subcanvas size
rectangle(mCanvas, Rect(cellX, cellY, cellW, cellH), Scalar(200, 200, 200), 1);
Mat cell(mCanvas, mask);
Mat imgResz;
// get cell aspect
double cellAspect = (double) cellW / (double) cellH;
// get image
Mat img = mSubImages[i];
// get image aspect
double imgAspect = (double) img.cols / (double) img.cols;
double wAspect = (double) cellW / (double) img.cols;
double hAspect = (double) cellH / (double) img.rows;
// get suitable aspect and resize image
double aspect = cellAspect < imgAspect ? wAspect : hAspect;
resize(img, imgResz, Size(0, 0), aspect, aspect);
// if gray image, convert to BGR
if(imgResz.channels() == 1){
cvtColor(imgResz, imgResz, COLOR_GRAY2BGR);
}
Mat subCell(mCanvas, Rect(cellX, cellY, imgResz.cols, imgResz.rows));
imgResz.copyTo(subCell);
putText(cell, title, Point(20, 20), FONT_HERSHEY_SIMPLEX, 0.6, Scalar(255, 0, 0));
}
// show total canvas
imshow(mWindowTitle, mCanvas);
}
2）設計通用輔助函式utils.hpp, utills.cpp和utils.inl
/*
@File :utils.hpp
@Description: :
@Date :2021/12/25 09:23:48
@Author :xieyin
@version :1.0
*/
#pragma once
#include<string>
#include<cmath>
#include<memory>
using namespace std;
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/ml.hpp>
using namespace cv;
using namespace cv::ml;
#include"mwindow.hpp"
extern shared_ptr<MWindow> myWin;
// generate randow color basd on randow number generator
Scalar randColor(RNG& rng);
// calculate given img's light pattert with large kernel's Blur operation
Mat calLigthPattern(Mat img);
// use 2 tpyes of light removal method, 0 diff, 1 div, defalut is 0
Mat removeLight(Mat img, Mat pattern, int methodLight=0);
// packed opencv lib connectedComponents function
Mat connectedComponents(Mat img_thr);
// packed opencv lib connectedComponentsWithStats function
Mat connectedComponentsWithStats(Mat img_thr);
// packed opencv lib findContours function
Mat findContours(Mat img_thr);
// helper function for trainAndTest, readFolderAndExtractFeatures
bool readFolderAndExtractFeatures(string filePath, int label, int numTest,
vector<float>& trainingData, vector<int>& trainResponses, vector<float>& testData, vector<int>& testResponses);
// helper function for trainAndTest, ploat data error
void plotData(Mat trainingDataMat, Mat trainResponsesMat, string mode="svm", float* error=NULL);
// define svm parameters
void defineSVM(Ptr<SVM>& svm);
// the train and test process for mechain learning
template<typename T>
void trainAndTest(string mode="svm");
// train svm model
void trainSVM();
// predict features extracted from imgOut, and put text in left top position
template<typename T>
void predict(vector<vector<float>> features, vector<int> posLeft, vector<int> posTop, string mode, Mat& imgOut);
// preprocess test image
Mat preProcess(Mat img);
// extract feature from preprocess image and get left top location
vector<vector<float>> extractFeatures(Mat img, vector<int>* posLeft=NULL, vector<int>* posTop=NULL);
#include"utils.inl"
/*
@File :utils.cpp
@Description: :
@Date :2021/12/25 09:23:38
@Author :xieyin
@version :1.0
*/
#include<string>
#include<cmath>
#include<memory>
#include<iostream>
#include<vector>
using namespace std;
#include<opencv2/core.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc.hpp>
#include<opencv2/opencv.hpp>
#include<opencv2/ml.hpp>
using namespace cv;
using namespace cv::ml;
#include"utils.hpp"
#include"mwindow.hpp"
Scalar randColor(RNG& rng){
/*
@description : generate randow color
@param :
rng : random number generator object
@Returns :
Sacalar() : BGR scalar
*/
auto iColor = (unsigned)rng;
return Scalar(iColor&255, (iColor >> 8)&255, (iColor >> 16)&255);
}
Mat calLigthPattern(Mat img){
/*
@description : get source image's light pattern
@param :
img : source BGR image or Gray image
@Returns :
pattern : the light pattern
*/
Mat pattern;
blur(img, pattern, Size(img.cols / 3, img.cols / 3));
return pattern;
}
Mat removeLight(Mat img, Mat pattern, int methodLight){
/*
@description : remove light between img and pattern based on method light
@param :
img : source BGR/Gray image
pattern : pattern BGR/Gray image
methodLight : choise options: 0 difference, 1 div
@Returns :
aux : light removed BGR/Gray image
*/
Mat aux;
if(methodLight == 1){
// div operation in float 32 format CV_32F
Mat img32, pattern32;
img.convertTo(img32, 5);
pattern.convertTo(pattern32, 5);
aux = 1.0 - (img32 / pattern32);
// covert to CV_8U and clip
aux.convertTo(aux, 0, 255);
}
else{
// difference
aux = pattern - img;
}
return aux;
}
Mat connectedComponents(Mat img_thr){
/*
@description : opencv connnected components
@param :
img : threshold image
@Returns :
None
*/
Mat labels;
auto num_objs = connectedComponents(img_thr, labels);
Mat res;
if(num_objs < 2){
cout << "no object is detected. " << endl;
return res;
}
res = Mat::zeros(img_thr.rows, img_thr.cols, CV_8UC3);
RNG rng(0xFFFFFFFF);
for(auto i = 1; i < num_objs; i++){
Mat mask = labels == i;
res.setTo(randColor(rng), mask);
}
return res;
}
Mat connectedComponentsWithStats(Mat img_thr){
/*
@description : connnected components with stats
@param :
img : threshold image
@Returns :
None
*/
Mat labels, stats, centroids;
auto num_objs = connectedComponentsWithStats(img_thr, labels, stats, centroids);
Mat res;
if(num_objs < 2){
cout << "no object is detected. " << endl;
return res;
}
res = Mat::zeros(img_thr.rows, img_thr.cols, CV_8UC3);
RNG rng(0xFFFFFFFF);
for(auto i = 1; i < num_objs; i++){
Mat mask = labels == i;
res.setTo(randColor(rng), mask);
stringstream ss;
ss << "area: " << stats.at<int>(i, CC_STAT_AREA);
// add text info
putText(res, ss.str(), centroids.at<Point2d>(i), FONT_HERSHEY_SIMPLEX, 0.3, Scalar(0, 255, 0));
}
return res;
}
Mat findContours(Mat img_thr){
/*
@description : find contours and put text
@param :
img : threshold image
@Returns :
None
*/
vector<vector<Point>> contours;
findContours(img_thr, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
Mat res;
if(contours.size() == 0){
cout << "no contours are found ." << endl;
return res;
}
RNG rng(0xFFFFFFFF);
res = Mat::zeros(img_thr.rows, img_thr.cols, CV_8UC3);
// calculate moments
vector<Moments> mu(contours.size());
for (int i = 0; i < contours.size(); i++)
{
mu[i] = moments(contours[i], false);
}
// calculate centroids
vector<Point2f> mc(contours.size());
for (int i = 0; i < contours.size(); i++)
{
mc[i] = Point2d(mu[i].m10 / mu[i].m00, mu[i].m01 / mu[i].m00);
}
for(auto i = 0; i < contours.size(); i++){
drawContours(res, contours, i, randColor(rng));
putText(res, "*", Point(mc[i].x, mc[i].y), FONT_HERSHEY_SIMPLEX, 0.4, Scalar(255, 0, 255), 1);
}
return res;
}
// helper function for readFolderAndExtractFeatures, preprocess image to binary image
Mat preProcess(Mat img){
/*
@description : preprocess img to denoise and remove light
@param :
img : image to process
@Returns :
*/
if(img.channels() == 3){
cvtColor(img, img, COLOR_BGR2GRAY);
}
Mat imgOut, imgNoise, imgLight;
medianBlur(img, imgNoise, 3);
imgNoise.copyTo(imgLight);
// read lightPat
Mat lightPat = imread("data/pattern.pgm", 0);
imgLight = removeLight(imgNoise, lightPat);
threshold(imgLight, imgOut, 30, 255, THRESH_BINARY);
return imgOut;
}
// helper function for trainAndTest, readFolderAndExtractFeatures
bool readFolderAndExtractFeatures(string filePath, int label, int numTest,
vector<float> &trainingData, vector<int> &trainResponses, vector<float> &testData, vector<int> &testResponses){
/*
@description : read file data and extract area and aspect features
@param :
filePath : image file path
label : image lable to classify
numTest : number for test
trainingData : trainingData feature: area, aspect
trainResponses : trainingData label
testData : testData feature: area, aspect
testResponses : testData label
@Returns :
(ref return) : trainingData, trainResponses, testData, testResponses
*/
vector<String> files;
// get folder
glob(filePath, files, true);
Mat frame;
int imgIdx = 0;
if(files.size() == 0){
return false;
}
for(int i = 0; i < files.size(); i++){
frame = imread(files[i]);
// preprocess image
Mat pre = preProcess(frame);
// get n features pair for each image
vector<vector<float>> features = extractFeatures(pre);
for(int i = 0; i < features.size(); i++){
// first numTest for model test
if(imgIdx >= numTest){
trainingData.push_back(features[i][0]);
trainingData.push_back(features[i][1]);
trainResponses.push_back(label);
}else{
testData.push_back(features[i][0]);
testData.push_back(features[i][1]);
testResponses.push_back(label);
}
}
imgIdx++;
}
return true;
}
// helper function for trainAndTest, ploat data error
void plotData(Mat trainingDataMat, Mat trainResponsesMat, string mode, float* error){
/*
@description : ploat train data feature (x: area, y: aspect) distributiion
@param :
trainingDataMat : trainingDataMat shape [N/2, 2], N is trainData vector size
trainResponsesMat : trainResponsesMat shape [N, 1], N is trainData label vector size
error : total error rate to display
@Returns :
None
*/
float areaMax, areaMin, asMax, asMin;
areaMax = asMax = 0.0;
areaMin = asMin = 99999999;
for(int i = 0; i < trainingDataMat.rows; i++){
float area = trainingDataMat.at<float>(i, 0);
float aspect = trainingDataMat.at<float>(i, 1);
// get min, max value
if(area > areaMax){
areaMax = area;
}
if(aspect > asMax){
asMax = aspect;
}
if(areaMin > area){
areaMin = area;
}
if(asMin > area){
asMin = aspect;
}
}
// create image to display
Mat fig = Mat::zeros(512, 512, CV_8UC3);
for(int i = 0; i < trainingDataMat.rows; i++){
float area = trainingDataMat.at<float>(i, 0);
float aspect = trainingDataMat.at<float>(i, 1);
// min-max norm [0~1] * 420 pixel
int x = (int)(420.0f*((area - areaMin) / (areaMax - areaMin)));
int y = (int)(420.0f*((aspect - asMin) / (asMax - asMin)));
int label = trainResponsesMat.at<int>(i);
Scalar color;
if(label == 0){
color = Scalar(255, 0, 0);
}else if(label == 1){
color = Scalar(0, 255, 0);
}else if(label == 2){
color = Scalar(0, 0, 255);
}
// cicle locate with start at(80, 80) to overcome border
circle(fig, Point(x+80, y+80), 3, color, -1, 8);
}
if(error != NULL){
stringstream ss;
ss << mode << " error: " << *error << " \%";
putText(fig, ss.str(), Point(20, 512-40), FONT_HERSHEY_SIMPLEX, 0.75, Scalar(200, 200, 200), 1, LINE_AA);
}
myWin->addImage("Fig", fig);
}
void defineSVM(Ptr<SVM>& svm){
/*
@description : define svm parameters
@param :
svm : svm model
@Returns :
(ref return) : svm with parameters
*/
svm = SVM::create();
svm->setType(SVM::C_SVC);
svm->setNu(0.05);
svm->setKernel(SVM::CHI2);
svm->setDegree(1.0);
svm->setGamma(2.0);
svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 1e-6));
}
void trainSVM(){
/*
@description : train a svm model and test its error rate
@param :
mode : machine learning mode
@Returns :
None
*/
vector<float> trainingData;
vector<int> trainResponses;
vector<float> testData;
vector<int> testResponses;
int numTest = 20;
string nutPath = "data/nut";
string ringPath = "data/ring";
string screwPath = "data/screw";
// read data path and extract feature
readFolderAndExtractFeatures(nutPath, 0, numTest, trainingData, trainResponses, testData, testResponses);
readFolderAndExtractFeatures(ringPath, 1, numTest, trainingData, trainResponses, testData, testResponses);
readFolderAndExtractFeatures(screwPath, 2, numTest, trainingData, trainResponses, testData, testResponses);
// cout << "Num of train samples: " << trainingData.size() << endl;
// cout << "Num of test samples: " << testData.size() << endl;
Mat trainingDataMat(trainingData.size() / 2, 2, CV_32FC1, &trainingData[0]);
Mat trainResponsesMat(trainResponses.size(), 1, CV_32SC1, &trainResponses[0]);
Mat testDataMat(testData.size() / 2, 2, CV_32FC1, &testData[0]);
Mat testResponsesMat(testResponses.size(), 1, CV_32SC1, &testResponses[0]);
// set row sample
Ptr<TrainData> tData = TrainData::create(trainingDataMat, ROW_SAMPLE, trainResponsesMat);
// select model
Ptr<SVM> model = SVM::create();
defineSVM(model);
model->train(tData);
model->save("model/svm.xml");
if(testResponses.size() > 0){
Mat testPredict;
// predict
model->predict(testDataMat, testPredict);
testPredict.convertTo(testPredict, CV_32SC1);
Mat errMat = testPredict != testResponsesMat;
float error = 100.0f * countNonZero(errMat) / testResponses.size();
cout << "svm" << " Error rate: " << error << "\%" << endl;
plotData(trainingDataMat, trainResponsesMat, "svm", &error);
}
else{
plotData(trainingDataMat, trainResponsesMat, "svm");
}
}
vector<vector<float>> extractFeatures(Mat img, vector<int>* posLeft, vector<int>* posTop){
/*
@description : extract image features and get left top loation
@param :
img : image to get feature
postLeft : left top_left location
postTop : top top_left location
@Returns :
features: extracted feature
*/
vector<vector<float>> features;
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
Mat temp = img.clone();
// find contours
findContours(temp, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
if(contours.size() == 0){
return features;
}
for(int i = 0; i < contours.size(); i++){
Mat mask = Mat::zeros(img.rows, img.cols, CV_8UC1);
// draw contours
drawContours(mask, contours, i, Scalar(1), FILLED, LINE_8, hierarchy, 1);
// get area value
Scalar areaSum = sum(mask);
float area = areaSum[0];
if(area > 500){
// calculate aspect for area is larger than 500
RotatedRect r = minAreaRect(contours[i]);
float w = r.size.width;
float h = r.size.height;
float aspect = w < h ? h / w : w / h;
vector<float> row;
// load calculated feature
row.push_back(area);
row.push_back(aspect);
features.push_back(row);
// load top_left location
if(posLeft != NULL){
posLeft->push_back((int)r.center.x);
}
if(posTop != NULL){
posTop->push_back((int)r.center.y);
}
myWin->addImage("Extracted Feature", mask * 255);
myWin->render();
waitKey(10);
}
}
return features;
}
/*
@File :utils.inl
@Description: :
@Date :2021/12/25 20:29:26
@Author :xieyin
@version :1.0
*/
template<typename T>
void trainAndTest(string mode){
/*
@description : train a svm model and test its error rate
@param :
mode : machine learning mode
@Returns :
None
*/
vector<float> trainingData;
vector<int> trainResponses;
vector<float> testData;
vector<int> testResponses;
int numTest = 20;
string nutPath = "data/nut";
string ringPath = "data/ring";
string screwPath = "data/screw";
// read data path and extract feature
readFolderAndExtractFeatures(nutPath, 0, numTest, trainingData, trainResponses, testData, testResponses);
readFolderAndExtractFeatures(ringPath, 1, numTest, trainingData, trainResponses, testData, testResponses);
readFolderAndExtractFeatures(screwPath, 2, numTest, trainingData, trainResponses, testData, testResponses);
// cout << "Num of train samples: " << trainingData.size() << endl;
// cout << "Num of test samples: " << testData.size() << endl;
Mat trainingDataMat(trainingData.size() / 2, 2, CV_32FC1, &trainingData[0]);
Mat trainResponsesMat(trainResponses.size(), 1, CV_32SC1, &trainResponses[0]);
Mat testDataMat(testData.size() / 2, 2, CV_32FC1, &testData[0]);
Mat testResponsesMat(testResponses.size(), 1, CV_32SC1, &testResponses[0]);
// set row sample
Ptr<TrainData> tData = TrainData::create(trainingDataMat, ROW_SAMPLE, trainResponsesMat);
// select model
Ptr<T> model = T::create();
model->train(tData);
model->save("model/" + mode + ".xml");
if(testResponses.size() > 0){
Mat testPredict;
// predict
model->predict(testDataMat, testPredict);
testPredict.convertTo(testPredict, CV_32SC1);
Mat errMat = testPredict != testResponsesMat;
float error = 100.0f * countNonZero(errMat) / testResponses.size();
cout << mode << " Error rate: " << error << "\%" << endl;
plotData(trainingDataMat, trainResponsesMat, mode, &error);
}
else{
plotData(trainingDataMat, trainResponsesMat, mode);
}
}
template<typename T>
void predict(vector<vector<float>> features, vector<int> posLeft, vector<int> posTop, string mode, Mat& imgOut){
/*
@description : predict features extracted from imgOut, and put text in left top position
@param :
features : extracted feature from imgOut
posLeft : left_top left location
posTop : left_top top location
mode : machine learning mode
imgOut : the img with text output
@Returns :
(ref return) : imgOut
*/
for(int i = 0; i < features.size(); i++){
Mat predDataMat(1, 2, CV_32FC1, &features[i][0]);
Ptr<T> model = Algorithm::load<T>("model/" + mode + ".xml");
float result = model->predict(predDataMat);
cout << result << endl;
stringstream ss;
Scalar color;
if(result == 0){
color = Scalar(255, 0, 0);
ss << "NUT";
}
else if(result == 1){
color = Scalar(0, 255, 0);
ss << "RING";
}
else if(result == 2){
color = Scalar(0, 255, 0);
ss << "SCREW";
}
putText(imgOut, ss.str(), Point2d(posLeft[i], posTop[i]), FONT_HERSHEY_SIMPLEX, 0.4, color);
}
}
3）主函式
/*
@File :main.cpp
@Description: :
@Date :2021/12/25 09:23:30
@Author :xieyin
@version :1.0
*/
#include<iostream>
#include<string>
#include<sstream>
#include<memory>
using namespace std;
#include<opencv2/core.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc.hpp>
#include<opencv2/opencv.hpp>
#include<opencv2/ml.hpp>
using namespace cv;
using namespace cv::ml;
#include"mwindow.hpp"
#include"utils.hpp"
const char* keys = {
"{help h usage ? | | Print this message}"
"{@image | | Image for test}"
"{@lightPat | | light pattern for test image}"
"{@mode | svm | machine learning mode, default svm}"
};
shared_ptr<MWindow> myWin;
int main(int argc, const char** argv){
// command line parser
CommandLineParser parser(argc, argv, keys);
if(parser.has("help")){
parser.printMessage();
return 0;
}
if(!parser.check()){
parser.printErrors();
return 0;
}
// define mywin
myWin = make_shared<MWindow>("Main Window", 2, 2, 700, 1000, 1);
// get test image path
String imgFile = parser.get<String>(0);
Mat img = imread(imgFile, 0);
if(img.data == NULL){
cout << "can not read image file." << endl;
return 0;
}
// get light pattern image
String ligPatFile = parser.get<String>(1);
Mat lightPat = imread(ligPatFile, 0);
if(lightPat.data == NULL){
cout << "can not read image file." << endl;
return 0;
}
// mdeianblur light pattern
medianBlur(lightPat, lightPat, 3);
// copy img to imgOut
Mat imgOut = img.clone();
cvtColor(imgOut, imgOut, COLOR_GRAY2BGR);
// preprocess image
Mat pre = preProcess(img);
// get feature and top left location from image
vector<int> posLeft, posTop;
vector<vector<float>> features = extractFeatures(pre, &posLeft, &posTop);
// get mode selection
string mode = parser.get<string>(2);
// train and predict model
if (mode == "svm"){
trainSVM();
// trainAndTest<SVM>(mode);
predict<SVM>(features, posLeft, posTop, mode, imgOut);
}
else if (mode == "bayes"){
trainAndTest<NormalBayesClassifier>(mode);
predict<NormalBayesClassifier>(features, posLeft, posTop, mode, imgOut);
}
else if(mode == "boost"){
trainAndTest<Boost>(mode);
predict<Boost>(features, posLeft, posTop, mode, imgOut);
}
else{
cout << "not support model";
return 0;
}
myWin->addImage("binary Image", pre);
myWin->addImage("result", imgOut);
myWin->render();
waitKey(0);
return 0;
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/394101.html
標籤：其他