Download modules/objdetect/src/barcode_decoder/upcean_decoder.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 10 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
- Command line
-
hf download hf://tgollogly/test/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
-
curl -L -o upcean_decoder.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
10 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. | |
| // Copyright (c) 2020-2021 darkliang wangberlinT Certseeds | |
| namespace cv { | |
| namespace barcode { | |
| static constexpr int DIVIDE_PART = 15; | |
| static constexpr int BIAS_PART = 2; | |
| void UPCEANDecoder::drawDebugLine(Mat &debug_img, const Point2i &begin, const Point2i &end) const | |
| { | |
| Result result; | |
| std::vector<uchar> middle; | |
| LineIterator line = LineIterator(debug_img, begin, end); | |
| middle.reserve(line.count); | |
| for (int cnt = 0; cnt < line.count; cnt++, line++) | |
| { | |
| middle.push_back(debug_img.at<uchar>(line.pos())); | |
| } | |
| std::pair<int, int> start_range; | |
| if (findStartGuardPatterns(middle, start_range)) | |
| { | |
| circle(debug_img, Point2i(begin.x + start_range.second, begin.y), 2, Scalar(0), 2); | |
| } | |
| result = this->decode(middle); | |
| if (result.format == Result::BARCODE_NONE) | |
| { | |
| result = this->decode(std::vector<uchar>(middle.crbegin(), middle.crend())); | |
| } | |
| if (result.format == Result::BARCODE_NONE) | |
| { | |
| cv::line(debug_img, begin, end, Scalar(0), 2); | |
| cv::putText(debug_img, result.result, begin, cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(0, 0, 255), 1); | |
| } | |
| } | |
| bool UPCEANDecoder::findGuardPatterns(const std::vector<uchar> &row, uint rowOffset, uchar whiteFirst, | |
| const std::vector<int> &pattern, Counter &counter, std::pair<uint, uint> &result) | |
| { | |
| size_t patternLength = pattern.size(); | |
| size_t width = row.size(); | |
| uchar color = whiteFirst ? WHITE : BLACK; | |
| rowOffset = (int) (std::find(row.cbegin() + rowOffset, row.cend(), color) - row.cbegin()); | |
| uint counterPosition = 0; | |
| uint patternStart = rowOffset; | |
| for (uint x = rowOffset; x < width; x++) | |
| { | |
| if (row[x] == color) | |
| { | |
| counter.pattern[counterPosition]++; | |
| counter.sum++; | |
| } | |
| else | |
| { | |
| if (counterPosition == patternLength - 1) | |
| { | |
| if (patternMatch(counter, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) | |
| { | |
| result.first = patternStart; | |
| result.second = x; | |
| return true; | |
| } | |
| patternStart += counter.pattern[0] + counter.pattern[1]; | |
| counter.sum -= counter.pattern[0] + counter.pattern[1]; | |
| std::copy(counter.pattern.begin() + 2, counter.pattern.end(), counter.pattern.begin()); | |
| counter.pattern[patternLength - 2] = 0; | |
| counter.pattern[patternLength - 1] = 0; | |
| counterPosition--; | |
| } | |
| else | |
| { | |
| counterPosition++; | |
| } | |
| counter.pattern[counterPosition] = 1; | |
| counter.sum++; | |
| color = (std::numeric_limits<uchar>::max() - color); | |
| } | |
| } | |
| return false; | |
| } | |
| bool UPCEANDecoder::findStartGuardPatterns(const std::vector<uchar> &row, std::pair<uint, uint> &start_range) | |
| { | |
| bool is_find = false; | |
| int next_start = 0; | |
| while (!is_find) | |
| { | |
| Counter guard_counters(std::vector<int>{0, 0, 0}); | |
| if (!findGuardPatterns(row, next_start, BLACK, BEGIN_PATTERN(), guard_counters, start_range)) | |
| { | |
| return false; | |
| } | |
| int start = static_cast<int>(start_range.first); | |
| next_start = static_cast<int>(start_range.second); | |
| int quiet_start = max(start - (next_start - start), 0); | |
| is_find = (quiet_start != start) && | |
| (std::find(std::begin(row) + quiet_start, std::begin(row) + start, BLACK) == std::begin(row) + start); | |
| } | |
| return true; | |
| } | |
| int UPCEANDecoder::decodeDigit(const std::vector<uchar> &row, Counter &counters, uint rowOffset, | |
| const std::vector<std::vector<int>> &patterns) | |
| { | |
| fillCounter(row, rowOffset, counters); | |
| int bestMatch = -1; | |
| uint bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept | |
| int i = 0; | |
| for (const auto &pattern : patterns) | |
| { | |
| uint variance = patternMatch(counters, pattern, MAX_INDIVIDUAL_VARIANCE); | |
| if (variance < bestVariance) | |
| { | |
| bestVariance = variance; | |
| bestMatch = i; | |
| } | |
| i++; | |
| } | |
| return std::max(-1, bestMatch); | |
| // -1 is Mismatch or means error. | |
| } | |
| /*Input a ROI mat return result */ | |
| std::pair<Result, float> UPCEANDecoder::decodeROI(const Mat &bar_img) const | |
| { | |
| if ((size_t) bar_img.cols < this->bits_num) | |
| { | |
| return std::make_pair(Result{string(), Result::BARCODE_NONE}, 0.0F); | |
| } | |
| std::map<std::string, int> result_vote; | |
| std::map<Result::BarcodeType, int> format_vote; | |
| int vote_cnt = 0; | |
| int total_vote = 0; | |
| std::string max_result; | |
| Result::BarcodeType max_type = Result::BARCODE_NONE; | |
| const int step = bar_img.rows / (DIVIDE_PART + BIAS_PART); | |
| Result result; | |
| int row_num; | |
| for (int i = 0; i < DIVIDE_PART; ++i) | |
| { | |
| row_num = (i + BIAS_PART / 2) * step; | |
| if (row_num < 0 || row_num > bar_img.rows) | |
| { | |
| continue; | |
| } | |
| const auto *ptr = bar_img.ptr<uchar>(row_num); | |
| vector<uchar> line(ptr, ptr + bar_img.cols); | |
| result = decodeLine(line); | |
| if (result.format != Result::BARCODE_NONE) | |
| { | |
| total_vote++; | |
| result_vote[result.result] += 1; | |
| if (result_vote[result.result] > vote_cnt) | |
| { | |
| vote_cnt = result_vote[result.result]; | |
| max_result = result.result; | |
| max_type = result.format; | |
| } | |
| } | |
| } | |
| if (total_vote == 0 || (vote_cnt << 2) < total_vote) | |
| { | |
| return std::make_pair(Result(string(), Result::BARCODE_NONE), 0.0f); | |
| } | |
| float confidence = (float) vote_cnt / (float) DIVIDE_PART; | |
| //Check if it is UPC-A format | |
| if (max_type == Result::BARCODE_EAN_13 && max_result[0] == '0') | |
| { | |
| max_result = max_result.substr(1, 12); //UPC-A length 12 | |
| max_type = Result::BARCODE_UPC_A; | |
| } | |
| return std::make_pair(Result(max_result, max_type), confidence); | |
| } | |
| Result UPCEANDecoder::decodeLine(const vector<uchar> &line) const | |
| { | |
| Result result = this->decode(line); | |
| if (result.format == Result::BARCODE_NONE) | |
| { | |
| result = this->decode(std::vector<uchar>(line.crbegin(), line.crend())); | |
| } | |
| return result; | |
| } | |
| bool UPCEANDecoder::isValid(const string &result) const | |
| { | |
| if (result.size() != digit_number) | |
| { | |
| return false; | |
| } | |
| int sum = 0; | |
| for (int index = (int) result.size() - 2, i = 1; index >= 0; index--, i++) | |
| { | |
| int temp = result[index] - '0'; | |
| sum += (temp + ((i & 1) != 0 ? temp << 1 : 0)); | |
| } | |
| return (result.back() - '0') == ((10 - (sum % 10)) % 10); | |
| } | |
| // right for A | |
| const std::vector<std::vector<int>> &get_A_or_C_Patterns() | |
| { | |
| static const std::vector<std::vector<int>> A_or_C_Patterns{{3, 2, 1, 1}, // 0 | |
| {2, 2, 2, 1}, // 1 | |
| {2, 1, 2, 2}, // 2 | |
| {1, 4, 1, 1}, // 3 | |
| {1, 1, 3, 2}, // 4 | |
| {1, 2, 3, 1}, // 5 | |
| {1, 1, 1, 4}, // 6 | |
| {1, 3, 1, 2}, // 7 | |
| {1, 2, 1, 3}, // 8 | |
| {3, 1, 1, 2} // 9 | |
| }; | |
| return A_or_C_Patterns; | |
| } | |
| const std::vector<std::vector<int>> &get_AB_Patterns() | |
| { | |
| static const std::vector<std::vector<int>> AB_Patterns = [] { | |
| constexpr uint offset = 10; | |
| auto AB_Patterns_inited = std::vector<std::vector<int>>(offset << 1, std::vector<int>(PATTERN_LENGTH, 0)); | |
| std::copy(get_A_or_C_Patterns().cbegin(), get_A_or_C_Patterns().cend(), AB_Patterns_inited.begin()); | |
| //AB pattern is | |
| for (uint i = 0; i < offset; ++i) | |
| { | |
| for (uint j = 0; j < PATTERN_LENGTH; ++j) | |
| { | |
| AB_Patterns_inited[i + offset][j] = AB_Patterns_inited[i][PATTERN_LENGTH - j - 1]; | |
| } | |
| } | |
| return AB_Patterns_inited; | |
| }(); | |
| return AB_Patterns; | |
| } | |
| const std::vector<int> &BEGIN_PATTERN() | |
| { | |
| // it just need it's 1:1:1(black:white:black) | |
| static const std::vector<int> BEGIN_PATTERN_(3, 1); | |
| return BEGIN_PATTERN_; | |
| } | |
| const std::vector<int> &MIDDLE_PATTERN() | |
| { | |
| // it just need it's 1:1:1:1:1(white:black:white:black:white) | |
| static const std::vector<int> MIDDLE_PATTERN_(5, 1); | |
| return MIDDLE_PATTERN_; | |
| } | |
| const std::array<char, 32> &FIRST_CHAR_ARRAY() | |
| { | |
| // use array to simulation a Hashmap, | |
| // because the data's size is small, | |
| // use a hashmap or brute-force search 10 times both can not accept | |
| static const std::array<char, 32> pattern{ | |
| '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x06', '\x00', '\x00', '\x00', '\x09', '\x00', | |
| '\x08', '\x03', '\x00', '\x00', '\x00', '\x00', '\x05', '\x00', '\x07', '\x02', '\x00', '\x00', '\x04', | |
| '\x01', '\x00', '\x00', '\x00', '\x00', '\x00'}; | |
| // length is 32 to ensure the security | |
| // 0x00000 -> 0 -> 0 | |
| // 0x11010 -> 26 -> 1 | |
| // 0x10110 -> 22 -> 2 | |
| // 0x01110 -> 14 -> 3 | |
| // 0x11001 -> 25 -> 4 | |
| // 0x10011 -> 19 -> 5 | |
| // 0x00111 -> 7 -> 6 | |
| // 0x10101 -> 21 -> 7 | |
| // 0x01101 -> 13 -> 8 | |
| // 0x01011 -> 11 -> 9 | |
| // delete the 1-13's 2 number's bit, | |
| // it always be A which do not need to count. | |
| return pattern; | |
| } | |
| } | |
| } // namespace cv | |