vs2022/C++/opencv4.52 ShapedMatch源码

#include "pch.h" #include "line2Dup.h" #include <iostream> using namespace std; using namespace cv; #include <chrono> class Timer { public: Timer() : beg_(clock_::now()) {} void reset() { beg_ = clock_::now(); } double elapsed() const { return std::chrono::duration_cast<second_> (clock_::now() - beg_).count(); } void out(std::string message = ""){ double t = elapsed(); std::cout << message << "\nelasped time:" << t << "s\n" << std::endl; reset(); } private: typedef std::chrono::high_resolution_clock clock_; typedef std::chrono::duration<double, std::ratio<1> > second_; std::chrono::time_point<clock_> beg_; }; namespace line2Dup { /** * \brief Get the label [0,8) of the single bit set in quantized. */ static inline int getLabel(int quantized) { switch (quantized) { case 1: return 0; case 2: return 1; case 4: return 2; case 8: return 3; case 16: return 4; case 32: return 5; case 64: return 6; case 128: return 7; default: CV_Error(Error::StsBadArg, "Invalid value of quantized parameter"); return -1; //avoid warning } } void Feature::read(const FileNode &fn) { FileNodeIterator fni = fn.begin(); fni >> x >> y >> label; } void Feature::write(FileStorage &fs) const { fs << "[:" << x << y << label << "]"; } void Template::read(const FileNode &fn) { width = fn["width"]; height = fn["height"]; tl_x = fn["tl_x"]; tl_y = fn["tl_y"]; pyramid_level = fn["pyramid_level"]; FileNode features_fn = fn["features"]; features.resize(features_fn.size()); FileNodeIterator it = features_fn.begin(), it_end = features_fn.end(); for (int i = 0; it != it_end; ++it, ++i) { features[i].read(*it); } } void Template::write(FileStorage &fs) const { fs << "width" << width; fs << "height" << height; fs << "tl_x" << tl_x; fs << "tl_y" << tl_y; fs << "pyramid_level" << pyramid_level; fs << "features" << "["; for (int i = 0; i < (int)features.size(); ++i) { features[i].write(fs); } fs << "]"; // features } static Rect cropTemplates(std::vector<Template> &templates) { int min_x = std::numeric_limits<int>::max(); int min_y = std::numeric_limits<int>::max(); int max_x = std::numeric_limits<int>::min(); int max_y = std::numeric_limits<int>::min(); // First pass: find min/max feature x,y over all pyramid levels and modalities for (int i = 0; i < (int)templates.size(); ++i) { Template &templ = templates[i]; for (int j = 0; j < (int)templ.features.size(); ++j) { int x = templ.features[j].x << templ.pyramid_level; int y = templ.features[j].y << templ.pyramid_level; min_x = std::min(min_x, x); min_y = std::min(min_y, y); max_x = std::max(max_x, x); max_y = std::max(max_y, y); } } /// @todo Why require even min_x, min_y? if (min_x % 2 == 1) --min_x; if (min_y % 2 == 1) --min_y; // Second pass: set width/height and shift all feature positions for (int i = 0; i < (int)templates.size(); ++i) { Template &templ = templates[i]; templ.width = (max_x - min_x) >> templ.pyramid_level; templ.height = (max_y - min_y) >> templ.pyramid_level; templ.tl_x = min_x >> templ.pyramid_level; templ.tl_y = min_y >> templ.pyramid_level; for (int j = 0; j < (int)templ.features.size(); ++j) { templ.features[j].x -= templ.tl_x; templ.features[j].y -= templ.tl_y; } } return Rect(min_x, min_y, max_x - min_x, max_y - min_y); } bool ColorGradientPyramid::selectScatteredFeatures(const std::vector<Candidate> &candidates, std::vector<Feature> &features, size_t num_features, float distance) { features.clear(); float distance_sq = distance * distance; int i = 0; bool first_select = true; while(true) { Candidate c = candidates[i]; // Add if sufficient distance away from any previously chosen feature bool keep = true; for (int j = 0; (j < (int)features.size()) && keep; ++j) { Feature f = features[j]; keep = (c.f.x - f.x) * (c.f.x - f.x) + (c.f.y - f.y) * (c.f.y - f.y) >= distance_sq; } if (keep) features.push_back(c.f); if (++i == (int)candidates.size()){ bool num_ok = features.size() >= num_features; if(first_select){ if(num_ok){ features.clear(); // we don't want too many first time i = 0; distance += 1.0f; distance_sq = distance * distance; continue; }else{ first_select = false; } } // Start back at beginning, and relax required distance i = 0; distance -= 1.0f; distance_sq = distance * distance; if (num_ok || distance < 3){ break; } } } return true; } /****************************************************************************************\ * Color gradient ColorGradient * \****************************************************************************************/ void hysteresisGradient(Mat &magnitude, Mat &quantized_angle, Mat &angle, float threshold) { // Quantize 360 degree range of orientations into 16 buckets // Note that [0, 11.25), [348.75, 360) both get mapped in the end to label 0, // for stability of horizontal and vertical features. Mat_<unsigned char> quantized_unfiltered; angle.convertTo(quantized_unfiltered, CV_8U, 16.0 / 360.0); // Zero out top and bottom rows /// @todo is this necessary, or even correct? memset(quantized_unfiltered.ptr(), 0, quantized_unfiltered.cols); memset(quantized_unfiltered.ptr(quantized_unfiltered.rows - 1), 0, quantized_unfiltered.cols); // Zero out first and last columns for (int r = 0; r < quantized_unfiltered.rows; ++r) { quantized_unfiltered(r, 0) = 0; quantized_unfiltered(r, quantized_unfiltered.cols - 1) = 0; } // Mask 16 buckets into 8 quantized orientations for (int r = 1; r < angle.rows - 1; ++r) { uchar *quant_r = quantized_unfiltered.ptr<uchar>(r); for (int c = 1; c < angle.cols - 1; ++c) { quant_r[c] &= 7; } } // Filter the raw quantized image. Only accept pixels where the magnitude is above some // threshold, and there is local agreement on the quantization. quantized_angle = Mat::zeros(angle.size(), CV_8U); for (int r = 1; r < angle.rows - 1; ++r) { float *mag_r = magnitude.ptr<float>(r); for (int c = 1; c < angle.cols - 1; ++c) { if (mag_r[c] > threshold) { // Compute histogram of quantized bins in 3x3 patch around pixel int histogram[8] = {0, 0, 0, 0, 0, 0, 0, 0}; uchar *patch3x3_row = &quantized_unfiltered(r - 1, c - 1); histogram[patch3x3_row[0]]++; histogram[patch3x3_row[1]]++; histogram[patch3x3_row[2]]++; patch3x3_row += quantized_unfiltered.step1(); histogram[patch3x3_row[0]]++; histogram[patch3x3_row[1]]++; histogram[patch3x3_row[2]]++; patch3x3_row += quantized_unfiltered.step1(); histogram[patc