2. 程式人生 > >Opencv中SVM樣本訓練、歸類流程及實現

Opencv中SVM樣本訓練、歸類流程及實現

阿新 • • 發佈：2019-02-09

支援向量機（SVM）中最核心的是什麼？個人理解就是前4個字——“支援向量”，一旦在兩類或多累樣本集中定位到某些特定的點作為支援向量，就可以依據這些支援向量計算出來分類超平面，再依據超平面對類別進行歸類劃分就是水到渠成的事了。有必要回顧一下什麼是支援向量機中的支援向量。


上圖中需要對紅色和藍色的兩類訓練樣本進行區分，實現綠線是決策面（超平面），最靠近決策面的2個實心紅色樣本和1個實心藍色樣本分別是兩類訓練樣本的支援向量，決策面所在的位置是使得兩類支援向量與決策面之間的間隔都達到最大時決策面所處的位置。一般情況下，訓練樣本都會存在噪聲，這就導致其中一類樣本的一個或多個樣本跑到了決策面的另一邊，摻雜到另一類樣本中。針對這種情況，SVM加入了鬆弛變數（懲罰變數）來應對，確保這些噪聲樣本不會被作為支援向量，而不管它們離超平面的距離有多近。包括SVM中的另一個重要概念“核函式”，也是為訓練樣本支援向量的確定提供支援的。

在OpenCV中，SVM的訓練、歸類流程如下：

1. 獲取訓練樣本

SVM是一種有監督的學習分類方法，所以對於給出的訓練樣本，要明確每個樣本的歸類是0還是1，即每個樣本都需要標註一個確切的類別標籤，提供給SVM訓練使用。對於樣本的特徵，以及特徵的維度，SVM並沒有限定，可以使用如Haar、角點、Sift、Surf、直方圖等各種特徵作為訓練樣本的表述參與SVM的訓練。Opencv要求訓練資料儲存在float型別的Mat結構中。最簡單的情況下，假定有兩類訓練樣本，樣本的維度是二維，每類包含3個樣本，可以定義如下：

    float labels[4] = {1.0, -1.0, -1.0, -1.0}; //樣本資料
    Mat labelsMat(3, 1, CV_32FC1, labels);     //樣本標籤
    float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} }; //Mat結構特徵資料
    Mat trainingDataMat(3, 2, CV_32FC1, trainingData);   //Mat結構標籤


2. 設定SVM引數

Opencv中SVM的引數設定在CvSVMParams類中，常用的設定包括SVM的型別，核函式型別和演算法的終止條件，鬆弛變數等。可以按如下設定：

    CvSVMParams params;
    params.svm_type    = CvSVM::C_SVC;
    params.kernel_type = CvSVM::LINEAR;
    params.term_crit   = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);

CVSVM::C_SVC型別是SVM中最常被用到的型別，它的重要特徵是可以處理非完美分類的問題（即訓練資料不可以被線性分割），包括線性可分割和不可分割。

核函式的目的是為了將訓練樣本對映到更有利於線性分割的樣本集中。對映的結果是增加了樣本向量的維度。這一過程通過核函式來完成。若設定核函式的型別是CvSVM::LINEAR表示不需要進行高維空間對映。

演算法終止條件，SVM訓練的過程是一個通過迭代方式解決約束條件下的二次優化問題，可以設定一個最大迭代次數和容許誤差的組合，以允許演算法在適當的條件下停止計算。

3. 訓練支援向量

通過Opencv中的CvSVM::train函式對訓練樣本進行訓練，並建立SVM模型。

CvSVM SVM;
    SVM.train(trainingDataMat, labelsMat, Mat(), Mat(), params);


4. 不同訓練樣本區域分割

函式CvSVM::predict可以運用之前建立的支援向量機的模型來判斷測試樣本空間中樣本所屬的類別，一種比較直觀的方式是對不同類別樣本所在的空間進行塗色，如下程式碼把兩類樣本空間分別圖上綠色和藍色，以示區分：

Vec3b green(0,255,0), blue (255,0,0);
    // Show the decision regions given by the SVM
    for (int i = 0; i < image.rows; ++i)
        for (int j = 0; j < image.cols; ++j)
        {
            Mat sampleMat = (Mat_<float>(1,2) << i,j);
            float response = SVM.predict(sampleMat);

            if (response == 1)
                image.at<Vec3b>(j, i)  = green;
            else if (response == -1) 
                 image.at<Vec3b>(j, i)  = blue;
        }

樣本區域分割效果，藍色和綠色區域代表不同的樣本空間，兩者交界處就是分類超平面位置：



5. 繪製支援向量

函式SVM.get_support_vector_count 可以獲取到支援向量的數量資訊，函式SVM.get_support_vector根據輸入支援向量的索引號來獲取指定位置的支援向量，如下程式碼獲取支援向量的數量，並在樣本空間中用紅色小圓圈逐個標識出來：

thickness = 2;
    lineType  = 8;
    int c     = SVM.get_support_vector_count();
    for (int i = 0; i < c; ++i)
    {
        const float* v = SVM.get_support_vector(i);
        circle( image,  Point( (int) v[0], (int) v[1]),   6,  Scalar(0, 0, 255), thickness, lineType);
    }


以上就是OpenCV中SVM樣本訓練以及歸類的詳細流程，無論是線性可分割還是線性不可分割都可以按照這5個基本步驟進行。

以下分別是SVM中線性可分二分類、線性不可分二分類和線性不可分多（三）分類問題的Opencv程式碼實現。

一、線性可分二分類問題

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>

using namespace cv;

int main()
{
    // Data for visual representation
    int width = 512, height = 512;
    Mat image = Mat::zeros(height, width, CV_8UC3);

    // Set up training data
    float labels[5] = {1.0, -1.0, -1.0, -1.0,1.0}; //樣本資料
    Mat labelsMat(4, 1, CV_32FC1, labels);     //樣本標籤
	float trainingData[5][2] = { {501, 300}, {255, 10}, {501, 255}, {10, 501},{450,500} }; //Mat結構特徵資料
    Mat trainingDataMat(4, 2, CV_32FC1, trainingData);   //Mat結構標籤

    // Set up SVM's parameters
    CvSVMParams params;
    params.svm_type    = CvSVM::C_SVC;
    params.kernel_type = CvSVM::LINEAR;
    params.term_crit   = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);

    // Train the SVM
    CvSVM SVM;
    SVM.train(trainingDataMat, labelsMat, Mat(), Mat(), params);
    
    Vec3b green(0,255,0), blue (255,0,0);
    // Show the decision regions given by the SVM
    for (int i = 0; i < image.rows; ++i)
        for (int j = 0; j < image.cols; ++j)
        {
            Mat sampleMat = (Mat_<float>(1,2) << i,j);
            float response = SVM.predict(sampleMat);

            if (response == 1)
                image.at<Vec3b>(j, i)  = green;
            else if (response == -1) 
                 image.at<Vec3b>(j, i)  = blue;
        }
		imshow("樣本區域分割",image);
		waitKey();

    // Show the training data
    int thickness = -1;
    int lineType = 8;
    circle( image, Point(501,  300), 5, Scalar(  0,   0,   0), thickness, lineType);
    circle( image, Point(255,  10), 5, Scalar(255, 255, 255), thickness, lineType);
    circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness, lineType);
    circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness, lineType);
    circle( image, Point( 450, 500), 5, Scalar(0, 0, 0), thickness, lineType);

    // Show support vectors
    thickness = 2;
    lineType  = 8;
    int c     = SVM.get_support_vector_count();
    for (int i = 0; i < c; ++i)
    {
        const float* v = SVM.get_support_vector(i);
        circle( image,  Point( (int) v[0], (int) v[1]),   6,  Scalar(0, 0, 255), thickness, lineType);
    }
    imwrite("result.png", image);        // save the image 

    imshow("SVM Simple Example", image); // show it to the user
    waitKey(0);
}

線性可分二分類問題的分類效果：


圖中右上角紅色的圓圈代表支援向量，位置明顯是錯的，據不可靠訊息，這個版本OpenCV的獲取支援向量的函式get_support_vector_count是有問題，具體各位可以自己驗證一下。

二、 線性不可分割問題

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>

#define	NTRAINING_SAMPLES	100			// Number of training samples per class
#define FRAC_LINEAR_SEP		0.9f	    // Fraction of samples which compose the linear separable part

using namespace cv;
using namespace std;


int main()
{   
	// Data for visual representation
	const int WIDTH = 512, HEIGHT = 512;
	Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);

	//--------------------- 1. Set up training data randomly ---------------------------------------
	Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32FC1);
	Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32FC1);

	RNG rng(100); // Random value generation class

	// Set up the linearly separable part of the training data
	int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);

	// Generate random points for the class 1
	Mat trainClass = trainData.rowRange(0, nLinearSamples);
	// The x coordinate of the points is in [0, 0.4)
	Mat c = trainClass.colRange(0, 1);
	rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(0.4 * WIDTH));
	// The y coordinate of the points is in [0, 1)
	c = trainClass.colRange(1,2);
	rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));

	// Generate random points for the class 2
	trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
	// The x coordinate of the points is in [0.6, 1]
	c = trainClass.colRange(0 , 1);
	rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
	// The y coordinate of the points is in [0, 1)
	c = trainClass.colRange(1,2);
	rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));

	//------------------ Set up the non-linearly separable part of the training data ---------------

	// Generate random points for the classes 1 and 2
	trainClass = trainData.rowRange(  nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
	// The x coordinate of the points is in [0.4, 0.6)
	c = trainClass.colRange(0,1);
	rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
	// The y coordinate of the points is in [0, 1)
	c = trainClass.colRange(1,2);
	rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));

	//------------------------- Set up the labels for the classes ---------------------------------
	labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // Class 1
	labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // Class 2

	//------------------------ 2. Set up the support vector machines parameters --------------------
	CvSVMParams params;
	params.svm_type    = SVM::C_SVC;
	params.C 		   = 0.1;
	params.kernel_type = SVM::LINEAR;
	params.term_crit   = TermCriteria(CV_TERMCRIT_ITER, (int)1e7, 1e-6);

	//------------------------ 3. Train the svm ----------------------------------------------------
	cout << "Starting training process" << endl;
	CvSVM svm;
	svm.train(trainData, labels, Mat(), Mat(), params);
	cout << "Finished training process" << endl;

	//------------------------ 4. Show the decision regions ----------------------------------------
	Vec3b green(0,100,0), blue (100,0,0);
	for (int i = 0; i < I.rows; ++i)
		for (int j = 0; j < I.cols; ++j)
		{
			Mat sampleMat = (Mat_<float>(1,2) << i, j);
			float response = svm.predict(sampleMat);

			if      (response == 1)    I.at<Vec3b>(j, i)  = green;
			else if (response == 2)    I.at<Vec3b>(j, i)  = blue;
		}

		//----------------------- 5. Show the training data --------------------------------------------
		int thick = -1;
		int lineType = 8;
		float px, py;
		// Class 1
		for (int i = 0; i < NTRAINING_SAMPLES; ++i)
		{
			px = trainData.at<float>(i,0);
			py = trainData.at<float>(i,1);
			circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick, lineType);
		}
		// Class 2
		for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; ++i)
		{
			px = trainData.at<float>(i,0);
			py = trainData.at<float>(i,1);
			circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick, lineType);
		}

		//------------------------- 6. Show support vectors --------------------------------------------
		thick = 2;
		lineType  = 8;
		int x     = svm.get_support_vector_count();

		for (int i = 0; i < x; ++i)
		{
			const float* v = svm.get_support_vector(i);
			circle(	I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick, lineType);
		}

		imwrite("result.png", I);	                   // save the Image
		imshow("線性不可分二類問題", I); // show it to the user
		waitKey(0);
}


訓練樣本空間最優分割面和訓練樣本分佈如下所示，在最優分割面附近有4個樣本點被當做噪點：


三、線性不可分多（三）分類問題

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>
#include <CTYPE.H>  

#define	NTRAINING_SAMPLES	100			// Number of training samples per class
#define FRAC_LINEAR_SEP		0.9f	    // Fraction of samples which compose the linear separable part

using namespace cv;
using namespace std;

int main(int argc, char* argv[])  
{  
	int size = 400; // height and widht of image  
	const int s = 1000; // number of data  
	int i, j,sv_num;  
	IplImage* img;  

	CvSVM svm ;  
	CvSVMParams param;  
	CvTermCriteria criteria; // 停止迭代標準  
	CvRNG rng = cvRNG();  
	CvPoint pts[s]; // 定義1000個點  
	float data[s*2]; // 點的座標  
	int res[s]; // 點的類別  

	CvMat data_mat, res_mat;  
	CvScalar rcolor;  

	const float* support;  

	// 影象區域的初始化  
	img = cvCreateImage(cvSize(size,size),IPL_DEPTH_8U,3);  
	cvZero(img);  

	// 學習資料的生成  
	for (i=0; i<s;++i)  
	{  
		pts[i].x = cvRandInt(&rng)%size;  
		pts[i].y = cvRandInt(&rng)%size;  

		if (pts[i].y>50*cos(pts[i].x*CV_PI/100)+200)  
		{  
			cvLine(img,cvPoint(pts[i].x-2,pts[i].y-2),cvPoint(pts[i].x+2,pts[i].y+2),CV_RGB(255,0,0));  
			cvLine(img,cvPoint(pts[i].x+2,pts[i].y-2),cvPoint(pts[i].x-2,pts[i].y+2),CV_RGB(255,0,0));  
			res[i]=1;  
		}  
		else  
		{  
			if (pts[i].x>200)  
			{  
				cvLine(img,cvPoint(pts[i].x-2,pts[i].y-2),cvPoint(pts[i].x+2,pts[i].y+2),CV_RGB(0,255,0));  
				cvLine(img,cvPoint(pts[i].x+2,pts[i].y-2),cvPoint(pts[i].x-2,pts[i].y+2),CV_RGB(0,255,0));  
				res[i]=2;  
			}  
			else  
			{  
				cvLine(img,cvPoint(pts[i].x-2,pts[i].y-2),cvPoint(pts[i].x+2,pts[i].y+2),CV_RGB(0,0,255));  
				cvLine(img,cvPoint(pts[i].x+2,pts[i].y-2),cvPoint(pts[i].x-2,pts[i].y+2),CV_RGB(0,0,255));  
				res[i]=3;  
			}  
		}  
	}  

	// 學習資料的現實  
	cvNamedWindow("SVM訓練樣本空間及分類",CV_WINDOW_AUTOSIZE);  
	cvShowImage("SVM訓練樣本空間及分類",img);  
	cvWaitKey(0);  

	// 學習引數的生成  
	for (i=0;i<s;++i)  
	{  
		data[i*2] = float(pts[i].x)/size;  
		data[i*2+1] = float(pts[i].y)/size;  
	}  

	cvInitMatHeader(&data_mat,s,2,CV_32FC1,data);  
	cvInitMatHeader(&res_mat,s,1,CV_32SC1,res);  
	criteria = cvTermCriteria(CV_TERMCRIT_EPS,1000,FLT_EPSILON);  
	param = CvSVMParams(CvSVM::C_SVC,CvSVM::RBF,10.0,8.0,1.0,10.0,0.5,0.1,NULL,criteria);  

	svm.train(&data_mat,&res_mat,NULL,NULL,param);  

	// 學習結果繪圖  
	for (i=0;i<size;i++)  
	{  
		for (j=0;j<size;j++)  
		{  
			CvMat m;  
			float ret = 0.0;  
			float a[] = {float(j)/size,float(i)/size};  
			cvInitMatHeader(&m,1,2,CV_32FC1,a);  
			ret = svm.predict(&m);  

			switch((int)ret)  
			{  
			case 1:  
				rcolor = CV_RGB(100,0,0);  
				break;  
			case 2:  
				rcolor = CV_RGB(0,100,0);  
				break;  
			case 3:  
				rcolor = CV_RGB(0,0,100);  
				break;  
			}  
			cvSet2D(img,i,j,rcolor);  
		}  
	}  


	// 為了顯示學習結果，通過對輸入影象區域的所有畫素（特徵向量）進行分類，然後對輸入的畫素用所屬顏色等級的顏色繪圖  
	for(i=0;i<s;++i)  
	{  
		CvScalar rcolor;  
		switch(res[i])  
		{  
		case 1:  
			rcolor = CV_RGB(255,0,0);  
			break;  
		case 2:  
			rcolor = CV_RGB(0,255,0);  
			break;  
		case 3:  
			rcolor = CV_RGB(0,0,255);  
			break;  
		}  
		cvLine(img,cvPoint(pts[i].x-2,pts[i].y-2),cvPoint(pts[i].x+2,pts[i].y+2),rcolor);  
		cvLine(img,cvPoint(pts[i].x+2,pts[i].y-2),cvPoint(pts[i].x-2,pts[i].y+2),rcolor);             
	}  

	// 支援向量的繪製  
	sv_num = svm.get_support_vector_count();  
	for (i=0; i<sv_num;++i)  
	{  
		support = svm.get_support_vector(i);  
		cvCircle(img,cvPoint((int)(support[0]*size),(int)(support[i]*size)),5,CV_RGB(200,200,200));  
	}  

	cvNamedWindow("SVM",CV_WINDOW_AUTOSIZE);  
	cvShowImage("SVM分類結果及支援向量",img);  
	cvWaitKey(0);  
	cvDestroyWindow("SVM");  
	cvReleaseImage(&img);  
	return 0;  
}


訓練樣本空間及分類：

   

SVM分類效果及支援向量：


相關推薦

Opencv中SVM樣本訓練、歸類流程及實現

支援向量機（SVM）中最核心的是什麼？個人理解就是前4個字——“支援向量”，一旦在兩類或多累樣本集中定位到某些特定的點作為支援向量，就可以依據這些支援向量計算出來分類超平面，再依據超平面對類別進行歸類劃分就是水到渠成的事了。有必要回顧一下什麼是支援向量機中的支援向量。

OpenCV中影象矩陣翻轉、轉置和特殊旋轉

在OpenCV中對影象進行翻轉和轉置的函式，可以很方便對影象進行特殊角度的旋轉！ 影象翻轉函式 cv::flip(mat_src,mat_dst,flag) 其中， flag=0 繞X軸（水平軸）翻轉 flag>0 繞Y軸（垂直軸）翻轉 flag<0

opencv 中SVM + PCA 人臉識別

這一週一直都在弄人臉識別的東西，這個也可以算是我個人第一個DIY專案，雖然沒有在MFC框架下來實現，但我覺得 SVM + PCA 人臉識別這個東西 最主要的還是演算法 和效果沒有必要一定要在MFC框架下去實現。 從不懂到慢慢明白一些道理，寫這樣一個技術文件無非就是怕以後忘記這樣一個過程。 從這個專案得到的經驗

OPENCV中SVM引數解析--學習1

先來看一下什麼是SVM(支援向量機) SVM是一種訓練機器學習的演算法，可以用於解決分類和迴歸問題，同時還使用了一種稱之為kernel trick（支援向量機的核函式）的技術進行資料的轉換，然後再根據這些轉換資訊，在可能的輸出之中找到一個最優的邊界(超平面)。簡單來說，就是做一些非常複雜的資料轉換工作，然

利用Opencv中的Haartraining訓練特徵的經驗談.....

最近需要熟悉一下haar特徵，帶著一個師妹熟悉一下從特徵提取到訓練的整個過程。 第一次接觸，熟悉玩haar特徵和adaboost原理後。實驗開始了 試驗中採用了MIT CACL人臉的資料庫。 實驗中產生樣本資料的命令如下： char order0[1024] = "open

shell中的函數、數組及告警系統需求分析

監控系統 發郵件 顯示元素 讀取 主程 unset shadow lan img 一、shell中的函數 函數就是把一段代碼整理到了一個小單元中，並給這個小單元起一個名字，當用到這段代碼時直接調用這個小單元的名字即可。 格式: function f_name() {

【機器學習】HOG+SVM進行車輛檢測的流程及原始碼

在進行機器學習檢測車道線時，參考了這篇博文，基於LBP+SVM實現了車道線檢測的初步效果。覺得講解很到位，程式碼也容易理解和修改，故在此分享，供更多人學習。原地址：https://www.cnblogs.com/louyihang-loves-baiyan/p/4658478.html HOG

OpenCV 中的split函式和merge函式 及示例

就讓我們來詳細介紹一下這兩個互為冤家的函式。首先是進行通道分離的split函式。 <1>split函式詳解 將一個多通道陣列分離成幾個單通道陣列。ps：這裡的array按語境譯為陣列或者陣列。 這個split函式的C++版本有兩個原型，他們分別是： C++:

QT+opencv學習筆記——邊緣檢測、輪廓提取及輪廓跟蹤

開發環境為：win10+QT5.8+opencv3.2 數字影象的邊緣檢測是影象分割、目標區域的識別、區域形狀提取等影象分析領域十分重要的基礎，影象分析和理解的第一步往往就是邊緣檢測。輪廓跟蹤是獲取影象的外部輪廓特徵，為影象的形狀分析做準備。本文主要實現影象邊緣檢測、輪廓提取、輪廓跟

如何修改word中的單位資訊、使用者資訊及文件屬性

文件屬性中的“使用者”資訊是可以通過工具選項中的使用者資訊修改的。但是單位資訊卻是在安裝OFFICE時設定的，經過我的測試，並不在NORMAL.DAT中，而是在登錄檔中。另外，有些人以為新使用者開啟OFFICE，第一次開啟的時候是可以輸入使用者資訊和單位資訊的，實際上是錯覺，

深度 | 機器學習中的模型評價、模型選擇及演算法選擇

作者：Sebastian Raschka翻譯：reason_W編輯：周翔簡介正確使用模型評估、模

關於OPENCV中imwrite出錯的一種可能及解決方法

以前一直用IplImage結構做載體，現在逐步轉成Mat,結果在imread和imwrite上出現了一些異常 主要表現為imwrite時出現異常情況. 我的程式碼:          if (ext == "bmp")         {             imwri

Java中刪除文件、刪除目錄及目錄下所有文件

bsp www als tro col int 某個文件 delet 刪除文件 原文鏈接：Java中刪除文件、刪除目錄及目錄下所有文件 知識點：File.delete()用於刪除“某個文件或者空目錄”！所以要刪除某個目錄及其中的所有文件和子目錄，要

Shiro許可權管理框架（三）：Shiro中許可權過濾器的初始化流程和實現原理

本篇是Shiro系列第三篇，Shiro中的過濾器初始化流程和實現原理。Shiro基於URL的許可權控制是通過Filter實現的，本篇從我們注入的ShiroFilterFactoryBean開始入手，翻看原始碼追尋Shiro中的過濾器的實現原理。 初始化流程 ShiroFilterFactoryBean實現

Spring事務專題（四）Spring中事務的使用、抽象機制及模擬Spring事務實現

Spring中事務的使用示例、屬性及使用中可能出現的問題 # 前言 本專題大綱如下： ![事務專題大綱](https://gitee.com/wx_cc347be696/blogImage/raw/master/image-20200808210340470.png) **對於專題大綱我又做了調整哈，

【進階3-3期】深度廣度解析 call 和 apply 原理、使用場景及實現

本週的主題是this全面解析，本計劃一共28期，每期重點攻克一個面試重難點，如果你還不瞭解本進階計劃，文末點選檢視全部文章。 如果覺得本系列不錯，歡迎轉發，您的支援就是我堅持的最大動力。 之前文章詳細介紹了 this 的使用，不瞭解的檢視【進階3-1期】。 call() 和 apply()

最短路徑演算法比較（Dijkstra、Bellman-Ford、SPFA）及實現（Java）

Bellman-Ford(Java) package com; import java.util.Scanner; public class Bellman_Ford { private static E edge[]; private static int

快速排序-常見中軸(主元pivot)選擇方法及實現程式碼（末位/隨機/三數中值/..）

一、選取最後一個元素 在我們的課本中，看到最多的就是選擇第一個元素作為中軸，但是在很多書上卻選擇最後一個元素作為中軸。下面就讓我們來一睹選取最後一個元素作為中軸的快排。 注：本文中的所有演算法都採用雙向掃描法，即，設兩個下標i和j，i和右掃描，j向左掃描，直到i不小

Android進階——自定義View之View的繪製流程及實現onMeasure完全攻略

引言 Android實際專案開發中，自定義View不可或缺，而作為自定義View的一種重要實現方式——繼承View重繪尤其重要，前面很多文章基本總結了繼承View的基本流程：自定義屬性和繼承View重寫onDraw方法——>實現構造方法並完成相關初始化操

Mybatis 程式碼流程及實現原理解析(三)

接上篇， 這篇繼續分析XMLMapperBuilder.parse()裡的configurationElement() 這個方法。 private void configurationElement(XNode context) { try { //m