Download modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 7.26 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
- Command line
-
hf download hf://tgollogly/test/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
-
curl -L -o hybrid_binarizer.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
7.26 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. | |
| // Modified from ZXing. Copyright ZXing authors. | |
| // Licensed under the Apache License, Version 2.0 (the "License"). | |
| namespace cv { | |
| namespace barcode { | |
| // This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels. | |
| // So this is the smallest dimension in each axis we can accept. | |
| constexpr static int BLOCK_SIZE_POWER = 3; | |
| constexpr static int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00 | |
| constexpr static int BLOCK_SIZE_MASK = BLOCK_SIZE - 1; // ...0011...11 | |
| constexpr static int MINIMUM_DIMENSION = BLOCK_SIZE * 5; | |
| constexpr static int MIN_DYNAMIC_RANGE = 24; | |
| void | |
| calculateThresholdForBlock(const std::vector<uchar> &luminances, int sub_width, int sub_height, int width, int height, | |
| const Mat &black_points, Mat &dst) | |
| { | |
| int maxYOffset = height - BLOCK_SIZE; | |
| int maxXOffset = width - BLOCK_SIZE; | |
| for (int y = 0; y < sub_height; y++) | |
| { | |
| int yoffset = y << BLOCK_SIZE_POWER; | |
| if (yoffset > maxYOffset) | |
| { | |
| yoffset = maxYOffset; | |
| } | |
| int top = CLAMP(y, 2, sub_height - 3); | |
| for (int x = 0; x < sub_width; x++) | |
| { | |
| int xoffset = x << BLOCK_SIZE_POWER; | |
| if (xoffset > maxXOffset) | |
| { | |
| xoffset = maxXOffset; | |
| } | |
| int left = CLAMP(x, 2, sub_width - 3); | |
| int sum = 0; | |
| const auto *black_row = black_points.ptr<uchar>(top - 2); | |
| for (int z = 0; z <= 4; z++) | |
| { | |
| sum += black_row[left - 2] + black_row[left - 1] + black_row[left] + black_row[left + 1] + | |
| black_row[left + 2]; | |
| black_row += black_points.cols; | |
| } | |
| int average = sum / 25; | |
| int temp_y = 0; | |
| auto *ptr = dst.ptr<uchar>(yoffset, xoffset); | |
| for (int offset = yoffset * width + xoffset; temp_y < 8; offset += width) | |
| { | |
| for (int temp_x = 0; temp_x < 8; ++temp_x) | |
| { | |
| *(ptr + temp_x) = (luminances[offset + temp_x] & 255) <= average ? 0 : 255; | |
| } | |
| ++temp_y; | |
| ptr += width; | |
| } | |
| } | |
| } | |
| } | |
| Mat calculateBlackPoints(std::vector<uchar> luminances, int sub_width, int sub_height, int width, int height) | |
| { | |
| int maxYOffset = height - BLOCK_SIZE; | |
| int maxXOffset = width - BLOCK_SIZE; | |
| Mat black_points(Size(sub_width, sub_height), CV_8UC1); | |
| for (int y = 0; y < sub_height; y++) | |
| { | |
| int yoffset = y << BLOCK_SIZE_POWER; | |
| if (yoffset > maxYOffset) | |
| { | |
| yoffset = maxYOffset; | |
| } | |
| for (int x = 0; x < sub_width; x++) | |
| { | |
| int xoffset = x << BLOCK_SIZE_POWER; | |
| if (xoffset > maxXOffset) | |
| { | |
| xoffset = maxXOffset; | |
| } | |
| int sum = 0; | |
| int min = 0xFF; | |
| int max = 0; | |
| for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) | |
| { | |
| for (int xx = 0; xx < BLOCK_SIZE; xx++) | |
| { | |
| int pixel = luminances[offset + xx] & 0xFF; | |
| sum += pixel; | |
| // still looking for good contrast | |
| if (pixel < min) | |
| { | |
| min = pixel; | |
| } | |
| if (pixel > max) | |
| { | |
| max = pixel; | |
| } | |
| } | |
| // short-circuit min/max tests once dynamic range is met | |
| if (max - min > MIN_DYNAMIC_RANGE) | |
| { | |
| // finish the rest of the rows quickly | |
| for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) | |
| { | |
| for (int xx = 0; xx < BLOCK_SIZE; xx++) | |
| { | |
| sum += luminances[offset + xx] & 0xFF; | |
| } | |
| } | |
| } | |
| } | |
| // The default estimate is the average of the values in the block. | |
| int average = sum >> (BLOCK_SIZE_POWER * 2); | |
| if (max - min <= MIN_DYNAMIC_RANGE) | |
| { | |
| // If variation within the block is low, assume this is a block with only light or only | |
| // dark pixels. In that case we do not want to use the average, as it would divide this | |
| // low contrast area into black and white pixels, essentially creating data out of noise. | |
| // | |
| // The default assumption is that the block is light/background. Since no estimate for | |
| // the level of dark pixels exists locally, use half the min for the block. | |
| average = min / 2; | |
| if (y > 0 && x > 0) | |
| { | |
| // Correct the "white background" assumption for blocks that have neighbors by comparing | |
| // the pixels in this block to the previously calculated black points. This is based on | |
| // the fact that dark barcode symbology is always surrounded by some amount of light | |
| // background for which reasonable black point estimates were made. The bp estimated at | |
| // the boundaries is used for the interior. | |
| // The (min < bp) is arbitrary but works better than other heuristics that were tried. | |
| int averageNeighborBlackPoint = | |
| (black_points.at<uchar>(y - 1, x) + (2 * black_points.at<uchar>(y, x - 1)) + | |
| black_points.at<uchar>(y - 1, x - 1)) / 4; | |
| if (min < averageNeighborBlackPoint) | |
| { | |
| average = averageNeighborBlackPoint; | |
| } | |
| } | |
| } | |
| black_points.at<uchar>(y, x) = (uchar) average; | |
| } | |
| } | |
| return black_points; | |
| } | |
| void hybridBinarization(const Mat &src, Mat &dst) | |
| { | |
| int width = src.cols; | |
| int height = src.rows; | |
| if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) | |
| { | |
| std::vector<uchar> luminances(src.begin<uchar>(), src.end<uchar>()); | |
| int sub_width = width >> BLOCK_SIZE_POWER; | |
| if ((width & BLOCK_SIZE_MASK) != 0) | |
| { | |
| sub_width++; | |
| } | |
| int sub_height = height >> BLOCK_SIZE_POWER; | |
| if ((height & BLOCK_SIZE_MASK) != 0) | |
| { | |
| sub_height++; | |
| } | |
| Mat black_points = calculateBlackPoints(luminances, sub_width, sub_height, width, height); | |
| dst.create(src.size(), src.type()); | |
| calculateThresholdForBlock(luminances, sub_width, sub_height, width, height, black_points, dst); | |
| } | |
| else | |
| { | |
| threshold(src, dst, 155, 255, THRESH_OTSU + THRESH_BINARY); | |
| } | |
| } | |
| } | |
| } | |