From c85262370b4172a2e3324f8c8b76fc829ab7e553 Mon Sep 17 00:00:00 2001 From: Vladislav Sovrasov Date: Tue, 21 Feb 2017 16:09:25 +0300 Subject: [PATCH] tracking: add parameters I/O for KCF --- .../include/opencv2/tracking/tracker.hpp | 10 +-- modules/tracking/src/trackerKCF.cpp | 60 ++++++++++++++++- .../test/test_trackerParametersIO.cpp | 67 +++++++++++++++++++ 3 files changed, 130 insertions(+), 7 deletions(-) diff --git a/modules/tracking/include/opencv2/tracking/tracker.hpp b/modules/tracking/include/opencv2/tracking/tracker.hpp index 88301d254..15003b9f9 100644 --- a/modules/tracking/include/opencv2/tracking/tracker.hpp +++ b/modules/tracking/include/opencv2/tracking/tracker.hpp @@ -1219,9 +1219,9 @@ public: - "CN" -- Color-names feature */ enum MODE { - GRAY = (1u << 0), - CN = (1u << 1), - CUSTOM = (1u << 2) + GRAY = (1 << 0), + CN = (1 << 1), + CUSTOM = (1 << 2) }; struct CV_EXPORTS Params @@ -1252,8 +1252,8 @@ public: bool compress_feature; //!< activate the pca method to compress the features int max_patch_size; //!< threshold for the ROI size int compressed_size; //!< feature size after compression - unsigned int desc_pca; //!< compressed descriptors of TrackerKCF::MODE - unsigned int desc_npca; //!< non-compressed descriptors of TrackerKCF::MODE + int desc_pca; //!< compressed descriptors of TrackerKCF::MODE + int desc_npca; //!< non-compressed descriptors of TrackerKCF::MODE }; virtual void setFeatureExtractor(void(*)(const Mat, const Rect, Mat&), bool pca_func = false); diff --git a/modules/tracking/src/trackerKCF.cpp b/modules/tracking/src/trackerKCF.cpp index 5ccc3f47b..47dd854a7 100644 --- a/modules/tracking/src/trackerKCF.cpp +++ b/modules/tracking/src/trackerKCF.cpp @@ -834,9 +834,65 @@ namespace cv{ pca_learning_rate=0.15; } - void TrackerKCF::Params::read( const cv::FileNode& /*fn*/ ){} + void TrackerKCF::Params::read( const cv::FileNode& fn ){ + *this = TrackerKCF::Params(); - void TrackerKCF::Params::write( cv::FileStorage& /*fs*/ ) const{} + if (!fn["sigma"].empty()) + fn["sigma"] >> sigma; + + if (!fn["lambda"].empty()) + fn["lambda"] >> lambda; + + if (!fn["interp_factor"].empty()) + fn["interp_factor"] >> interp_factor; + + if (!fn["output_sigma_factor"].empty()) + fn["output_sigma_factor"] >> output_sigma_factor; + + if (!fn["resize"].empty()) + fn["resize"] >> resize; + + if (!fn["max_patch_size"].empty()) + fn["max_patch_size"] >> max_patch_size; + + if (!fn["split_coeff"].empty()) + fn["split_coeff"] >> split_coeff; + + if (!fn["wrap_kernel"].empty()) + fn["wrap_kernel"] >> wrap_kernel; + + + if (!fn["desc_npca"].empty()) + fn["desc_npca"] >> desc_npca; + + if (!fn["desc_pca"].empty()) + fn["desc_pca"] >> desc_pca; + + if (!fn["compress_feature"].empty()) + fn["compress_feature"] >> compress_feature; + + if (!fn["compressed_size"].empty()) + fn["compressed_size"] >> compressed_size; + + if (!fn["pca_learning_rate"].empty()) + fn["pca_learning_rate"] >> pca_learning_rate; + } + + void TrackerKCF::Params::write( cv::FileStorage& fs ) const{ + fs << "sigma" << sigma; + fs << "lambda" << lambda; + fs << "interp_factor" << interp_factor; + fs << "output_sigma_factor" << output_sigma_factor; + fs << "resize" << resize; + fs << "max_patch_size" << max_patch_size; + fs << "split_coeff" << split_coeff; + fs << "wrap_kernel" << wrap_kernel; + fs << "desc_npca" << desc_npca; + fs << "desc_pca" << desc_pca; + fs << "compress_feature" << compress_feature; + fs << "compressed_size" << compressed_size; + fs << "pca_learning_rate" << pca_learning_rate; + } void TrackerKCF::setFeatureExtractor(void (*)(const Mat, const Rect, Mat&), bool ){}; diff --git a/modules/tracking/test/test_trackerParametersIO.cpp b/modules/tracking/test/test_trackerParametersIO.cpp index beda09c40..2af198b5b 100644 --- a/modules/tracking/test/test_trackerParametersIO.cpp +++ b/modules/tracking/test/test_trackerParametersIO.cpp @@ -58,3 +58,70 @@ TEST(MEDIAN_FLOW_Parameters_IO_Default_Value_If_Absent, MEDIAN_FLOW) ASSERT_EQ(defaultParameters.termCriteria.epsilon, readParameters.termCriteria.epsilon); ASSERT_EQ(defaultParameters.termCriteria.maxCount, readParameters.termCriteria.maxCount); } + +TEST(KCF_Parameters, IO) +{ + TrackerKCF::Params parameters; + + parameters.sigma = 0.3; + parameters.lambda = 0.02; + parameters.interp_factor = 0.08; + parameters.output_sigma_factor = 1.0/ 32.0; + parameters.resize=false; + parameters.max_patch_size=90*90; + parameters.split_coeff=false; + parameters.wrap_kernel=true; + parameters.desc_npca = TrackerKCF::CN; + parameters.desc_pca = TrackerKCF::GRAY; + parameters.compress_feature=false; + parameters.compressed_size=3; + parameters.pca_learning_rate=0.2; + + FileStorage fsWriter("parameters.xml", FileStorage::WRITE + FileStorage::MEMORY); + parameters.write(fsWriter); + + String serializedParameters = fsWriter.releaseAndGetString(); + + FileStorage fsReader(serializedParameters, FileStorage::READ + FileStorage::MEMORY); + + TrackerKCF::Params readParameters; + readParameters.read(fsReader.root()); + + ASSERT_DOUBLE_EQ(parameters.sigma, readParameters.sigma); + ASSERT_DOUBLE_EQ(parameters.lambda, readParameters.lambda); + ASSERT_DOUBLE_EQ(parameters.interp_factor, readParameters.interp_factor); + ASSERT_DOUBLE_EQ(parameters.output_sigma_factor, readParameters.output_sigma_factor); + ASSERT_EQ(parameters.resize, readParameters.resize); + ASSERT_EQ(parameters.max_patch_size, readParameters.max_patch_size); + ASSERT_EQ(parameters.split_coeff, readParameters.split_coeff); + ASSERT_EQ(parameters.wrap_kernel, readParameters.wrap_kernel); + ASSERT_EQ(parameters.desc_npca, readParameters.desc_npca); + ASSERT_EQ(parameters.desc_pca, readParameters.desc_pca); + ASSERT_EQ(parameters.compress_feature, readParameters.compress_feature); + ASSERT_EQ(parameters.compressed_size, readParameters.compressed_size); + ASSERT_DOUBLE_EQ(parameters.pca_learning_rate, readParameters.pca_learning_rate); +} + +TEST(KCF_Parameters, Default_Value_If_Absent) +{ + TrackerKCF::Params defaultParameters; + + FileStorage fsReader(String("%YAML 1.0"), FileStorage::READ + FileStorage::MEMORY); + + TrackerKCF::Params readParameters; + readParameters.read(fsReader.root()); + + ASSERT_DOUBLE_EQ(defaultParameters.sigma, readParameters.sigma); + ASSERT_DOUBLE_EQ(defaultParameters.lambda, readParameters.lambda); + ASSERT_DOUBLE_EQ(defaultParameters.interp_factor, readParameters.interp_factor); + ASSERT_DOUBLE_EQ(defaultParameters.output_sigma_factor, readParameters.output_sigma_factor); + ASSERT_EQ(defaultParameters.resize, readParameters.resize); + ASSERT_EQ(defaultParameters.max_patch_size, readParameters.max_patch_size); + ASSERT_EQ(defaultParameters.split_coeff, readParameters.split_coeff); + ASSERT_EQ(defaultParameters.wrap_kernel, readParameters.wrap_kernel); + ASSERT_EQ(defaultParameters.desc_npca, readParameters.desc_npca); + ASSERT_EQ(defaultParameters.desc_pca, readParameters.desc_pca); + ASSERT_EQ(defaultParameters.compress_feature, readParameters.compress_feature); + ASSERT_EQ(defaultParameters.compressed_size, readParameters.compressed_size); + ASSERT_DOUBLE_EQ(defaultParameters.pca_learning_rate, readParameters.pca_learning_rate); +}