Download modules/imgproc/src/contours_link.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/imgproc/src/contours_link.cpp
- Command line
-
hf download hf://tgollogly/test/modules/imgproc/src/contours_link.cpp
-
curl -L -o contours_link.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/imgproc/src/contours_link.cpp
12.3 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html | |
| using namespace cv; | |
| using namespace std; | |
| //============================================================================== | |
| namespace { | |
| inline static int findStartContourPoint(uchar* src_data, Size img_size, int j) | |
| { | |
| v_uint8 v_zero = vx_setzero_u8(); | |
| for (; j <= img_size.width - VTraits<v_uint8>::vlanes(); j += VTraits<v_uint8>::vlanes()) | |
| { | |
| v_uint8 vmask = (v_ne(vx_load((uchar*)(src_data + j)), v_zero)); | |
| if (v_check_any(vmask)) | |
| { | |
| j += v_scan_forward(vmask); | |
| return j; | |
| } | |
| } | |
| for (; j < img_size.width && !src_data[j]; ++j) | |
| ; | |
| return j; | |
| } | |
| inline static int findEndContourPoint(uchar* src_data, Size img_size, int j) | |
| { | |
| if (j < img_size.width && !src_data[j]) | |
| { | |
| return j; | |
| } | |
| else | |
| { | |
| v_uint8 v_zero = vx_setzero_u8(); | |
| for (; j <= img_size.width - VTraits<v_uint8>::vlanes(); j += VTraits<v_uint8>::vlanes()) | |
| { | |
| v_uint8 vmask = (v_eq(vx_load((uchar*)(src_data + j)), v_zero)); | |
| if (v_check_any(vmask)) | |
| { | |
| j += v_scan_forward(vmask); | |
| return j; | |
| } | |
| } | |
| } | |
| for (; j < img_size.width && src_data[j]; ++j) | |
| ; | |
| return j; | |
| } | |
| //============================================================================== | |
| struct LinkRunPoint | |
| { | |
| int link; | |
| int next; | |
| Point pt; | |
| LinkRunPoint() : link(-1), next(-1) {} | |
| LinkRunPoint(const Point& pt_) : link(-1), next(-1), pt(pt_) {} | |
| }; | |
| typedef LinkRunPoint LRP; | |
| //============================================================================== | |
| class LinkRunner | |
| { | |
| public: | |
| enum LinkConnectionDirection | |
| { | |
| ICV_SINGLE = 0, | |
| ICV_CONNECTING_ABOVE = 1, | |
| ICV_CONNECTING_BELOW = -1, | |
| }; | |
| CTree tree; | |
| vector<LRP> rns; | |
| vector<int> ext_rns; | |
| vector<int> int_rns; | |
| public: | |
| LinkRunner() | |
| { | |
| tree.newElem(); | |
| rns.reserve(100); | |
| } | |
| void process(Mat& image); | |
| void convertLinks(int& first, int& prev, bool isHole); | |
| void establishLinks(int& prev_point, | |
| int upper_run, | |
| int lower_run, | |
| const int upper_total, | |
| const int lower_total); | |
| }; | |
| void LinkRunner::convertLinks(int& first, int& prev, bool isHole) | |
| { | |
| const vector<int>& contours = isHole ? int_rns : ext_rns; | |
| int count = 0; | |
| for (int j = 0; j < (int)contours.size(); j++, count++) | |
| { | |
| int start = contours[j]; | |
| int cur = start; | |
| if (rns[cur].link == -1) | |
| continue; | |
| CNode& node = tree.newElem(); | |
| node.body.isHole = isHole; | |
| do | |
| { | |
| node.body.pts.push_back(rns[cur].pt); | |
| int p_temp = cur; | |
| cur = rns[cur].link; | |
| rns[p_temp].link = -1; | |
| } | |
| while (cur != start); | |
| if (first == 0) | |
| { | |
| tree.addChild(0, node.self()); | |
| prev = first = node.self(); | |
| } | |
| else | |
| { | |
| tree.addSiblingAfter(prev, node.self()); | |
| prev = node.self(); | |
| } | |
| } | |
| } | |
| void LinkRunner::establishLinks(int& prev_point, | |
| int upper_run, | |
| int lower_run, | |
| const int upper_total, | |
| const int lower_total) | |
| { | |
| int k, n; | |
| int connect_flag = ICV_SINGLE; | |
| for (k = 0, n = 0; k < upper_total / 2 && n < lower_total / 2;) | |
| { | |
| switch (connect_flag) | |
| { | |
| case ICV_SINGLE: | |
| if (rns[rns[upper_run].next].pt.x < rns[rns[lower_run].next].pt.x) | |
| { | |
| if (rns[rns[upper_run].next].pt.x >= rns[lower_run].pt.x - 1) | |
| { | |
| rns[lower_run].link = upper_run; | |
| connect_flag = ICV_CONNECTING_ABOVE; | |
| prev_point = rns[upper_run].next; | |
| } | |
| else | |
| rns[rns[upper_run].next].link = upper_run; | |
| k++; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| else | |
| { | |
| if (rns[upper_run].pt.x <= rns[rns[lower_run].next].pt.x + 1) | |
| { | |
| rns[lower_run].link = upper_run; | |
| connect_flag = ICV_CONNECTING_BELOW; | |
| prev_point = rns[lower_run].next; | |
| } | |
| else | |
| { | |
| rns[lower_run].link = rns[lower_run].next; | |
| // First point of contour | |
| ext_rns.push_back(lower_run); | |
| } | |
| n++; | |
| lower_run = rns[rns[lower_run].next].next; | |
| } | |
| break; | |
| case ICV_CONNECTING_ABOVE: | |
| if (rns[upper_run].pt.x > rns[rns[lower_run].next].pt.x + 1) | |
| { | |
| rns[prev_point].link = rns[lower_run].next; | |
| connect_flag = ICV_SINGLE; | |
| n++; | |
| lower_run = rns[rns[lower_run].next].next; | |
| } | |
| else | |
| { | |
| rns[prev_point].link = upper_run; | |
| if (rns[rns[upper_run].next].pt.x < rns[rns[lower_run].next].pt.x) | |
| { | |
| k++; | |
| prev_point = rns[upper_run].next; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| else | |
| { | |
| connect_flag = ICV_CONNECTING_BELOW; | |
| prev_point = rns[lower_run].next; | |
| n++; | |
| lower_run = rns[rns[lower_run].next].next; | |
| } | |
| } | |
| break; | |
| case ICV_CONNECTING_BELOW: | |
| if (rns[lower_run].pt.x > rns[rns[upper_run].next].pt.x + 1) | |
| { | |
| rns[rns[upper_run].next].link = prev_point; | |
| connect_flag = ICV_SINGLE; | |
| k++; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| else | |
| { | |
| // First point of contour | |
| int_rns.push_back(lower_run); | |
| rns[lower_run].link = prev_point; | |
| if (rns[rns[lower_run].next].pt.x < rns[rns[upper_run].next].pt.x) | |
| { | |
| n++; | |
| prev_point = rns[lower_run].next; | |
| lower_run = rns[rns[lower_run].next].next; | |
| } | |
| else | |
| { | |
| connect_flag = ICV_CONNECTING_ABOVE; | |
| k++; | |
| prev_point = rns[upper_run].next; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| } | |
| break; | |
| } | |
| } // k, n | |
| for (; n < lower_total / 2; n++) | |
| { | |
| if (connect_flag != ICV_SINGLE) | |
| { | |
| rns[prev_point].link = rns[lower_run].next; | |
| connect_flag = ICV_SINGLE; | |
| lower_run = rns[rns[lower_run].next].next; | |
| continue; | |
| } | |
| rns[lower_run].link = rns[lower_run].next; | |
| // First point of contour | |
| ext_rns.push_back(lower_run); | |
| lower_run = rns[rns[lower_run].next].next; | |
| } | |
| for (; k < upper_total / 2; k++) | |
| { | |
| if (connect_flag != ICV_SINGLE) | |
| { | |
| rns[rns[upper_run].next].link = prev_point; | |
| connect_flag = ICV_SINGLE; | |
| upper_run = rns[rns[upper_run].next].next; | |
| continue; | |
| } | |
| rns[rns[upper_run].next].link = upper_run; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| } | |
| void LinkRunner::process(Mat& image) | |
| { | |
| const Size sz = image.size(); | |
| int j; | |
| int lower_total; | |
| int upper_total; | |
| int all_total; | |
| Point cur_point; | |
| rns.reserve(sz.height); // optimization, assuming some contours exist | |
| // First line. None of runs is binded | |
| rns.push_back(LRP()); | |
| int upper_line = (int)rns.size() - 1; | |
| int cur = upper_line; | |
| for (j = 0; j < sz.width;) | |
| { | |
| j = findStartContourPoint(image.ptr<uchar>(), sz, j); | |
| if (j == sz.width) | |
| break; | |
| cur_point.x = j; | |
| rns.push_back(LRP(cur_point)); | |
| rns[cur].next = (int)rns.size() - 1; | |
| cur = rns[cur].next; | |
| j = findEndContourPoint(image.ptr<uchar>(), sz, j + 1); | |
| cur_point.x = j - 1; | |
| rns.push_back(LRP(cur_point)); | |
| rns[cur].next = (int)rns.size() - 1; | |
| rns[cur].link = rns[cur].next; | |
| // First point of contour | |
| ext_rns.push_back(cur); | |
| cur = rns[cur].next; | |
| } | |
| upper_line = rns[upper_line].next; | |
| upper_total = (int)rns.size() - 1; // runs->total - 1; | |
| int last_elem = cur; | |
| rns[cur].next = -1; | |
| int prev_point = -1; | |
| int lower_line = -1; | |
| for (int i = 1; i < sz.height; i++) | |
| { | |
| // Find runs in next line | |
| cur_point.y = i; | |
| all_total = (int)rns.size(); // runs->total; | |
| for (j = 0; j < sz.width;) | |
| { | |
| j = findStartContourPoint(image.ptr<uchar>(i), sz, j); | |
| if (j == sz.width) | |
| break; | |
| cur_point.x = j; | |
| rns.push_back(LRP(cur_point)); | |
| rns[cur].next = (int)rns.size() - 1; | |
| cur = rns[cur].next; | |
| j = findEndContourPoint(image.ptr<uchar>(i), sz, j + 1); | |
| cur_point.x = j - 1; | |
| rns.push_back(LRP(cur_point)); | |
| cur = rns[cur].next = (int)rns.size() - 1; | |
| } // j | |
| lower_line = rns[last_elem].next; | |
| lower_total = (int)rns.size() - all_total; // runs->total - all_total; | |
| last_elem = cur; | |
| rns[cur].next = -1; | |
| CV_DbgAssert(rns.size() < (size_t)numeric_limits<int>::max()); | |
| // Find links between runs of lower_line and upper_line | |
| establishLinks(prev_point, upper_line, lower_line, upper_total, lower_total); | |
| upper_line = lower_line; | |
| upper_total = lower_total; | |
| } // i | |
| // the last line of image | |
| int upper_run = upper_line; | |
| for (int k = 0; k < upper_total / 2; k++) | |
| { | |
| rns[rns[upper_run].next].link = upper_run; | |
| upper_run = rns[rns[upper_run].next].next; | |
| } | |
| int first = 0; | |
| int prev = 0; | |
| convertLinks(first, prev, false); | |
| convertLinks(first, prev, true); | |
| } | |
| } // namespace | |
| //============================================================================== | |
| void cv::findContoursLinkRuns(InputArray _image, | |
| OutputArrayOfArrays _contours, | |
| OutputArray _hierarchy) | |
| { | |
| CV_INSTRUMENT_REGION(); | |
| CV_CheckType(_image.type(), | |
| _image.type() == CV_8UC1 || _image.type() == CV_8SC1, | |
| "Bad input image type, must be CV_8UC1 or CV_8SC1"); | |
| // Sanity check: output must be of type vector<vector<Point>> | |
| CV_Assert(_contours.kind() == _InputArray::STD_VECTOR_VECTOR || | |
| _contours.kind() == _InputArray::STD_VECTOR_MAT || | |
| _contours.kind() == _InputArray::STD_VECTOR_UMAT); | |
| if (!_contours.empty()) | |
| CV_CheckTypeEQ(_contours.type(), CV_32SC2, "Contours must have type CV_32SC2"); | |
| if (_hierarchy.needed()) | |
| _hierarchy.clear(); | |
| Mat image = _image.getMat(); | |
| LinkRunner runner; | |
| runner.process(image); | |
| contourTreeToResults(runner.tree, CV_32SC2, _contours, _hierarchy); | |
| } | |
| void cv::findContoursLinkRuns(InputArray _image, OutputArrayOfArrays _contours) | |
| { | |
| CV_INSTRUMENT_REGION(); | |
| findContoursLinkRuns(_image, _contours, noArray()); | |
| } | |