OpenCV 3.3中給出了決策樹Decision Tres演算法的實現，即cv::ml::DTrees類，此類的宣告在include/opencv2/ml.hpp檔案中，實現在modules/ml/src/tree.cpp檔案中。其中：

(1)、cv::ml::DTrees類：繼承自cv::ml::StateModel，而cv::ml::StateModel又繼承自cv::Algorithm；

(2)、create函式：為static，new一個DTreesImpl物件用來建立一個DTrees物件；

(3)、setMaxCategories/getMaxCategories函式：設定/獲取最大的類別數，預設值為10；

(4)、setMaxDepth/getMaxDepth函式：設定/獲取樹的最大深度，預設值為INT_MAX；

(5)、setMinSampleCount/getMinSampleCount函式：設定/獲取最小訓練樣本數，預設值為10；

(6)、setCVFolds/getCVFolds函式：設定/獲取CVFolds(thenumber of cross-validation folds)值，預設值為10，如果此值大於1，用於修剪構建的決策樹；

(7)、setUseSurrogates/getUseSurrogates函式：設定/獲取是否使用surrogatesplits方法，預設值為false；

(8)、setUse1SERule/getUse1SERule函式：設定/獲取是否使用1-SE規則，預設值為true；

(9)、setTruncatePrunedTree/getTruncatedTree函式：設定/獲取是否進行剪枝後移除操作，預設值為true；

(10)、setRegressionAccuracy/getRegressionAccuracy函式：設定/獲取迴歸時用於終止的標準，預設值為0.01；

(11)、setPriors/getPriors函式：設定/獲取先驗概率數值，用於調整決策樹的偏好，預設值為空的Mat；

(12)、getRoots函式：獲取根節點索引；

(13)、getNodes函式：獲取所有節點索引；

(14)、getSplits函式：獲取所有拆分索引；

(15)、getSubsets函式：獲取分類拆分的所有bitsets；

(16)、load函式：load已序列化的model檔案。

以下是從資料集MNIST中提取的40幅影象，0,1,2,3四類各20張，每類的前10幅來自於訓練樣本，用於訓練，後10幅來自測試樣本，用於測試，如下圖：

測試程式碼如下：

#include "opencv.hpp"
#include <string>
#include <vector>
#include <memory>
#include <algorithm>
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>
#include "common.hpp"

///////////////////////////////////// Decision Tree ////////////////////////////////////////
int test_opencv_decision_tree_train()
{
	const std::string image_path{ "E:/GitCode/NN_Test/data/images/digit/handwriting_0_and_1/" };
	cv::Mat tmp = cv::imread(image_path + "0_1.jpg", 0);
	CHECK(tmp.data != nullptr);
	const int train_samples_number{ 40 };
	const int every_class_number{ 10 };

	cv::Mat train_data(train_samples_number, tmp.rows * tmp.cols, CV_32FC1);
	cv::Mat train_labels(train_samples_number, 1, CV_32FC1);
	float* p = (float*)train_labels.data;
	for (int i = 0; i < 4; ++i) {
		std::for_each(p + i * every_class_number, p + (i + 1)*every_class_number, [i](float& v){v = (float)i; });
	}

	// train data
	for (int i = 0; i < 4; ++i) {
		static const std::vector<std::string> digit{ "0_", "1_", "2_", "3_" };
		static const std::string suffix{ ".jpg" };

		for (int j = 1; j <= every_class_number; ++j) {
			std::string image_name = image_path + digit[i] + std::to_string(j) + suffix;
			cv::Mat image = cv::imread(image_name, 0);
			CHECK(!image.empty() && image.isContinuous());
			image.convertTo(image, CV_32FC1);

			image = image.reshape(0, 1);
			tmp = train_data.rowRange(i * every_class_number + j - 1, i * every_class_number + j);
			image.copyTo(tmp);
		}
	}

	cv::Ptr<cv::ml::DTrees> dtree = cv::ml::DTrees::create();
	dtree->setMaxCategories(4);
	dtree->setMaxDepth(10);
	dtree->setMinSampleCount(10);
	dtree->setCVFolds(0);
	dtree->setUseSurrogates(false);
	dtree->setUse1SERule(false);
	dtree->setTruncatePrunedTree(false);
	dtree->setRegressionAccuracy(0);
	dtree->setPriors(cv::Mat());

	dtree->train(train_data, cv::ml::ROW_SAMPLE, train_labels);

	const std::string save_file{ "E:/GitCode/NN_Test/data/decision_tree_model.xml" }; // .xml, .yaml, .jsons
	dtree->save(save_file);

	return 0;
}

int test_opencv_decision_tree_predict()
{
	const std::string image_path{ "E:/GitCode/NN_Test/data/images/digit/handwriting_0_and_1/" };
	const std::string load_file{ "E:/GitCode/NN_Test/data/decision_tree_model.xml" }; // .xml, .yaml, .jsons
	const int predict_samples_number{ 40 };
	const int every_class_number{ 10 };

	cv::Mat tmp = cv::imread(image_path + "0_1.jpg", 0);
	CHECK(tmp.data != nullptr);

	// predict datta
	cv::Mat predict_data(predict_samples_number, tmp.rows * tmp.cols, CV_32FC1);
	for (int i = 0; i < 4; ++i) {
		static const std::vector<std::string> digit{ "0_", "1_", "2_", "3_" };
		static const std::string suffix{ ".jpg" };

		for (int j = 11; j <= every_class_number + 10; ++j) {
			std::string image_name = image_path + digit[i] + std::to_string(j) + suffix;
			cv::Mat image = cv::imread(image_name, 0);
			CHECK(!image.empty() && image.isContinuous());
			image.convertTo(image, CV_32FC1);

			image = image.reshape(0, 1);
			tmp = predict_data.rowRange(i * every_class_number + j - 10 - 1, i * every_class_number + j - 10);
			image.copyTo(tmp);
		}
	}

	cv::Mat result;
	cv::Ptr<cv::ml::DTrees> dtrees = cv::ml::DTrees::load(load_file);

	dtrees->predict(predict_data, result);
	CHECK(result.rows == predict_samples_number);

	cv::Mat predict_labels(predict_samples_number, 1, CV_32FC1);
	float* p = (float*)predict_labels.data;
	for (int i = 0; i < 4; ++i) {
		std::for_each(p + i * every_class_number, p + (i + 1)*every_class_number, [i](float& v){v = (float)i; });
	}

	int count{ 0 };
	for (int i = 0; i < predict_samples_number; ++i) {
		float value1 = ((float*)predict_labels.data)[i];
		float value2 = ((float*)result.data)[i];
		fprintf(stdout, "expected value: %f, actual value: %f\n", value1, value2);

		if (int(value1) == int(value2)) ++count;
	}
	fprintf(stdout, "accuracy: %f\n", count * 1.f / predict_samples_number);

	return 0;
}