mirror of
https://github.com/opencv/opencv.git
synced 2026-07-31 00:03:03 +04:00
Merge branch 4.x
This commit is contained in:
Alexander Smorkalov
@@ -50,6 +50,7 @@ static inline bool readWrite(DetectorParameters ¶ms, const FileNode* readNod
|
||||
readNode, writeStorage);
|
||||
check |= readWriteParameter("minOtsuStdDev", params.minOtsuStdDev, readNode, writeStorage);
|
||||
check |= readWriteParameter("errorCorrectionRate", params.errorCorrectionRate, readNode, writeStorage);
|
||||
check |= readWriteParameter("minGroupDistance", params.minGroupDistance, readNode, writeStorage);
|
||||
// new aruco 3 functionality
|
||||
check |= readWriteParameter("useAruco3Detection", params.useAruco3Detection, readNode, writeStorage);
|
||||
check |= readWriteParameter("minSideLengthCanonicalImg", params.minSideLengthCanonicalImg, readNode, writeStorage);
|
||||
@@ -212,149 +213,65 @@ static void _reorderCandidatesCorners(vector<vector<Point2f> > &candidates) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief to make sure that the corner's order of both candidates (default/white) is the same
|
||||
*/
|
||||
static vector<Point2f> alignContourOrder(Point2f corner, vector<Point2f> candidate) {
|
||||
uint8_t r=0;
|
||||
double min = norm( Vec2f( corner - candidate[0] ), NORM_L2SQR);
|
||||
for(uint8_t pos=1; pos < 4; pos++) {
|
||||
double nDiff = norm( Vec2f( corner - candidate[pos] ), NORM_L2SQR);
|
||||
if(nDiff < min){
|
||||
r = pos;
|
||||
min =nDiff;
|
||||
}
|
||||
static float getAverageModuleSize(const vector<Point2f>& markerCorners, int markerSize, int markerBorderBits) {
|
||||
float averageArucoModuleSize = 0.f;
|
||||
for (size_t i = 0ull; i < 4ull; i++) {
|
||||
averageArucoModuleSize += sqrt(normL2Sqr<float>(Point2f(markerCorners[i] - markerCorners[(i+1ull) % 4ull])));
|
||||
}
|
||||
std::rotate(candidate.begin(), candidate.begin() + r, candidate.end());
|
||||
return candidate;
|
||||
int numModules = markerSize + markerBorderBits * 2;
|
||||
averageArucoModuleSize /= ((float)markerCorners.size()*numModules);
|
||||
return averageArucoModuleSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check candidates that are too close to each other, save the potential candidates
|
||||
* (i.e. biggest/smallest contour) and remove the rest
|
||||
*/
|
||||
static void _filterTooCloseCandidates(const vector<vector<Point2f> > &candidatesIn,
|
||||
vector<vector<vector<Point2f> > > &candidatesSetOut,
|
||||
const vector<vector<Point> > &contoursIn,
|
||||
vector<vector<vector<Point> > > &contoursSetOut,
|
||||
double minMarkerDistanceRate, bool detectInvertedMarker) {
|
||||
static bool checkMarker1InMarker2(const vector<Point2f>& marker1, const vector<Point2f>& marker2) {
|
||||
return pointPolygonTest(marker2, marker1[0], false) >= 0 && pointPolygonTest(marker2, marker1[1], false) >= 0 &&
|
||||
pointPolygonTest(marker2, marker1[2], false) >= 0 && pointPolygonTest(marker2, marker1[3], false) >= 0;
|
||||
}
|
||||
|
||||
CV_Assert(minMarkerDistanceRate >= 0);
|
||||
vector<int> candGroup;
|
||||
candGroup.resize(candidatesIn.size(), -1);
|
||||
vector<vector<unsigned int> > groupedCandidates;
|
||||
for(unsigned int i = 0; i < candidatesIn.size(); i++) {
|
||||
bool isSingleContour = true;
|
||||
for(unsigned int j = i + 1; j < candidatesIn.size(); j++) {
|
||||
struct MarkerCandidate {
|
||||
vector<Point2f> corners;
|
||||
vector<Point> contour;
|
||||
float perimeter = 0.f;
|
||||
};
|
||||
|
||||
int minimumPerimeter = min((int)contoursIn[i].size(), (int)contoursIn[j].size() );
|
||||
struct MarkerCandidateTree : MarkerCandidate{
|
||||
int parent = -1;
|
||||
int depth = 0;
|
||||
vector<MarkerCandidate> closeContours;
|
||||
|
||||
// fc is the first corner considered on one of the markers, 4 combinations are possible
|
||||
for(int fc = 0; fc < 4; fc++) {
|
||||
double distSq = 0;
|
||||
for(int c = 0; c < 4; c++) {
|
||||
// modC is the corner considering first corner is fc
|
||||
int modC = (c + fc) % 4;
|
||||
distSq += (candidatesIn[i][modC].x - candidatesIn[j][c].x) *
|
||||
(candidatesIn[i][modC].x - candidatesIn[j][c].x) +
|
||||
(candidatesIn[i][modC].y - candidatesIn[j][c].y) *
|
||||
(candidatesIn[i][modC].y - candidatesIn[j][c].y);
|
||||
}
|
||||
distSq /= 4.;
|
||||
MarkerCandidateTree() {}
|
||||
|
||||
// if mean square distance is too low, remove the smaller one of the two markers
|
||||
double minMarkerDistancePixels = double(minimumPerimeter) * minMarkerDistanceRate;
|
||||
if(distSq < minMarkerDistancePixels * minMarkerDistancePixels) {
|
||||
isSingleContour = false;
|
||||
// i and j are not related to a group
|
||||
if(candGroup[i]<0 && candGroup[j]<0){
|
||||
// mark candidates with their corresponding group number
|
||||
candGroup[i] = candGroup[j] = (int)groupedCandidates.size();
|
||||
|
||||
// create group
|
||||
vector<unsigned int> grouped;
|
||||
grouped.push_back(i);
|
||||
grouped.push_back(j);
|
||||
groupedCandidates.push_back( grouped );
|
||||
}
|
||||
// i is related to a group
|
||||
else if(candGroup[i] > -1 && candGroup[j] == -1){
|
||||
int group = candGroup[i];
|
||||
candGroup[j] = group;
|
||||
|
||||
// add to group
|
||||
groupedCandidates[group].push_back( j );
|
||||
}
|
||||
// j is related to a group
|
||||
else if(candGroup[j] > -1 && candGroup[i] == -1){
|
||||
int group = candGroup[j];
|
||||
candGroup[i] = group;
|
||||
|
||||
// add to group
|
||||
groupedCandidates[group].push_back( i );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isSingleContour && candGroup[i] < 0)
|
||||
{
|
||||
candGroup[i] = (int)groupedCandidates.size();
|
||||
vector<unsigned int> grouped;
|
||||
grouped.push_back(i);
|
||||
grouped.push_back(i); // step "save possible candidates" require minimum 2 elements
|
||||
groupedCandidates.push_back(grouped);
|
||||
MarkerCandidateTree(vector<Point2f>&& corners_, vector<Point>&& contour_) {
|
||||
corners = std::move(corners_);
|
||||
contour = std::move(contour_);
|
||||
perimeter = 0.f;
|
||||
for (size_t i = 0ull; i < 4ull; i++) {
|
||||
perimeter += sqrt(normL2Sqr<float>(Point2f(corners[i] - corners[(i+1ull) % 4ull])));
|
||||
}
|
||||
}
|
||||
|
||||
// save possible candidates
|
||||
candidatesSetOut.clear();
|
||||
contoursSetOut.clear();
|
||||
|
||||
vector<vector<Point2f> > biggerCandidates;
|
||||
vector<vector<Point> > biggerContours;
|
||||
vector<vector<Point2f> > smallerCandidates;
|
||||
vector<vector<Point> > smallerContours;
|
||||
|
||||
// save possible candidates
|
||||
for(unsigned int i = 0; i < groupedCandidates.size(); i++) {
|
||||
unsigned int smallerIdx = groupedCandidates[i][0];
|
||||
unsigned int biggerIdx = smallerIdx;
|
||||
double smallerArea = contourArea(candidatesIn[smallerIdx]);
|
||||
double biggerArea = smallerArea;
|
||||
|
||||
// evaluate group elements
|
||||
for(unsigned int j = 1; j < groupedCandidates[i].size(); j++) {
|
||||
unsigned int currIdx = groupedCandidates[i][j];
|
||||
double currArea = contourArea(candidatesIn[currIdx]);
|
||||
|
||||
// check if current contour is bigger
|
||||
if(currArea >= biggerArea) {
|
||||
biggerIdx = currIdx;
|
||||
biggerArea = currArea;
|
||||
}
|
||||
|
||||
// check if current contour is smaller
|
||||
if(currArea < smallerArea && detectInvertedMarker) {
|
||||
smallerIdx = currIdx;
|
||||
smallerArea = currArea;
|
||||
}
|
||||
}
|
||||
|
||||
// add contours and candidates
|
||||
biggerCandidates.push_back(candidatesIn[biggerIdx]);
|
||||
biggerContours.push_back(contoursIn[biggerIdx]);
|
||||
if(detectInvertedMarker) {
|
||||
smallerCandidates.push_back(alignContourOrder(candidatesIn[biggerIdx][0], candidatesIn[smallerIdx]));
|
||||
smallerContours.push_back(contoursIn[smallerIdx]);
|
||||
}
|
||||
bool operator<(const MarkerCandidateTree& m) const {
|
||||
// sorting the contors in descending order
|
||||
return perimeter > m.perimeter;
|
||||
}
|
||||
// to preserve the structure :: candidateSet< defaultCandidates, whiteCandidates >
|
||||
// default candidates
|
||||
candidatesSetOut.push_back(biggerCandidates);
|
||||
contoursSetOut.push_back(biggerContours);
|
||||
// white candidates
|
||||
candidatesSetOut.push_back(smallerCandidates);
|
||||
contoursSetOut.push_back(smallerContours);
|
||||
};
|
||||
|
||||
|
||||
// returns the average distance between the marker points
|
||||
float static inline getAverageDistance(const std::vector<Point2f>& marker1, const std::vector<Point2f>& marker2) {
|
||||
float minDistSq = std::numeric_limits<float>::max();
|
||||
// fc is the first corner considered on one of the markers, 4 combinations are possible
|
||||
for(int fc = 0; fc < 4; fc++) {
|
||||
float distSq = 0;
|
||||
for(int c = 0; c < 4; c++) {
|
||||
// modC is the corner considering first corner is fc
|
||||
int modC = (c + fc) % 4;
|
||||
distSq += normL2Sqr<float>(marker1[modC] - marker2[c]);
|
||||
}
|
||||
distSq /= 4.f;
|
||||
minDistSq = min(minDistSq, distSq);
|
||||
}
|
||||
return sqrt(minDistSq);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -403,29 +320,6 @@ static void _detectInitialCandidates(const Mat &grey, vector<vector<Point2f> > &
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Detect square candidates in the input image
|
||||
*/
|
||||
static void _detectCandidates(InputArray _grayImage, vector<vector<vector<Point2f> > >& candidatesSetOut,
|
||||
vector<vector<vector<Point> > >& contoursSetOut, const DetectorParameters &_params) {
|
||||
Mat grey = _grayImage.getMat();
|
||||
CV_DbgAssert(grey.total() != 0);
|
||||
CV_DbgAssert(grey.type() == CV_8UC1);
|
||||
|
||||
/// 1. DETECT FIRST SET OF CANDIDATES
|
||||
vector<vector<Point2f> > candidates;
|
||||
vector<vector<Point> > contours;
|
||||
_detectInitialCandidates(grey, candidates, contours, _params);
|
||||
/// 2. SORT CORNERS
|
||||
_reorderCandidatesCorners(candidates);
|
||||
|
||||
/// 3. FILTER OUT NEAR CANDIDATE PAIRS
|
||||
// save the outter/inner border (i.e. potential candidates)
|
||||
_filterTooCloseCandidates(candidates, candidatesSetOut, contours, contoursSetOut,
|
||||
_params.minMarkerDistanceRate, _params.detectInvertedMarker);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Given an input image and candidate corners, extract the bits of the candidate, including
|
||||
* the border bits
|
||||
@@ -527,12 +421,10 @@ static int _getBorderErrors(const Mat &bits, int markerSize, int borderSize) {
|
||||
* 1 if the candidate is a black candidate (default candidate)
|
||||
* 2 if the candidate is a white candidate
|
||||
*/
|
||||
static uint8_t _identifyOneCandidate(const Dictionary& dictionary, InputArray _image,
|
||||
static uint8_t _identifyOneCandidate(const Dictionary& dictionary, const Mat& _image,
|
||||
const vector<Point2f>& _corners, int& idx,
|
||||
const DetectorParameters& params, int& rotation,
|
||||
const float scale = 1.f) {
|
||||
CV_DbgAssert(_corners.size() == 4);
|
||||
CV_DbgAssert(_image.getMat().total() != 0);
|
||||
CV_DbgAssert(params.markerBorderBits > 0);
|
||||
uint8_t typ=1;
|
||||
// get bits
|
||||
@@ -610,87 +502,6 @@ static size_t _findOptPyrImageForCanonicalImg(
|
||||
return optLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Identify square candidates according to a marker dictionary
|
||||
*/
|
||||
|
||||
static void _identifyCandidates(InputArray grey,
|
||||
const vector<Mat>& image_pyr,
|
||||
vector<vector<vector<Point2f> > >& _candidatesSet,
|
||||
vector<vector<vector<Point> > >& _contoursSet, const Dictionary &_dictionary,
|
||||
vector<vector<Point2f> >& _accepted, vector<vector<Point> >& _contours, vector<int>& ids,
|
||||
const DetectorParameters ¶ms,
|
||||
OutputArrayOfArrays _rejected = noArray()) {
|
||||
CV_DbgAssert(grey.getMat().total() != 0);
|
||||
CV_DbgAssert(grey.getMat().type() == CV_8UC1);
|
||||
int ncandidates = (int)_candidatesSet[0].size();
|
||||
vector<vector<Point2f> > accepted;
|
||||
vector<vector<Point2f> > rejected;
|
||||
vector<vector<Point> > contours;
|
||||
|
||||
vector<int> idsTmp(ncandidates, -1);
|
||||
vector<int> rotated(ncandidates, 0);
|
||||
vector<uint8_t> validCandidates(ncandidates, 0);
|
||||
|
||||
//// Analyze each of the candidates
|
||||
parallel_for_(Range(0, ncandidates), [&](const Range &range) {
|
||||
const int begin = range.start;
|
||||
const int end = range.end;
|
||||
|
||||
vector<vector<Point2f> >& candidates = params.detectInvertedMarker ? _candidatesSet[1] : _candidatesSet[0];
|
||||
vector<vector<Point> >& contourS = params.detectInvertedMarker ? _contoursSet[1] : _contoursSet[0];
|
||||
|
||||
for(int i = begin; i < end; i++) {
|
||||
int currId = -1;
|
||||
// implements equation (4)
|
||||
if (params.useAruco3Detection) {
|
||||
const int perimeterOfContour = static_cast<int>(contourS[i].size());
|
||||
const int min_perimeter = params.minSideLengthCanonicalImg * 4;
|
||||
const size_t nearestImgId = _findOptPyrImageForCanonicalImg(image_pyr, grey.cols(), perimeterOfContour, min_perimeter);
|
||||
const float scale = image_pyr[nearestImgId].cols / static_cast<float>(grey.cols());
|
||||
|
||||
validCandidates[i] = _identifyOneCandidate(_dictionary, image_pyr[nearestImgId], candidates[i], currId, params, rotated[i], scale);
|
||||
}
|
||||
else {
|
||||
validCandidates[i] = _identifyOneCandidate(_dictionary, grey, candidates[i], currId, params, rotated[i]);
|
||||
}
|
||||
|
||||
if(validCandidates[i] > 0)
|
||||
idsTmp[i] = currId;
|
||||
}
|
||||
});
|
||||
|
||||
for(int i = 0; i < ncandidates; i++) {
|
||||
if(validCandidates[i] > 0) {
|
||||
// to choose the right set of candidates :: 0 for default, 1 for white markers
|
||||
uint8_t set = validCandidates[i]-1;
|
||||
|
||||
// shift corner positions to the correct rotation
|
||||
correctCornerPosition(_candidatesSet[set][i], rotated[i]);
|
||||
|
||||
if( !params.detectInvertedMarker && validCandidates[i] == 2 )
|
||||
continue;
|
||||
|
||||
// add valid candidate
|
||||
accepted.push_back(_candidatesSet[set][i]);
|
||||
ids.push_back(idsTmp[i]);
|
||||
|
||||
contours.push_back(_contoursSet[set][i]);
|
||||
|
||||
} else {
|
||||
rejected.push_back(_candidatesSet[0][i]);
|
||||
}
|
||||
}
|
||||
|
||||
// parse output
|
||||
_accepted = accepted;
|
||||
|
||||
_contours= contours;
|
||||
|
||||
if(_rejected.needed()) {
|
||||
_copyVector2Output(rejected, _rejected);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Line fitting A * B = C :: Called from function refineCandidateLines
|
||||
@@ -846,16 +657,210 @@ struct ArucoDetector::ArucoDetectorImpl {
|
||||
ArucoDetectorImpl(const Dictionary &_dictionary, const DetectorParameters &_detectorParams,
|
||||
const RefineParameters& _refineParams): dictionary(_dictionary),
|
||||
detectorParams(_detectorParams), refineParams(_refineParams) {}
|
||||
/**
|
||||
* @brief Detect square candidates in the input image
|
||||
*/
|
||||
void detectCandidates(const Mat& grey, vector<vector<Point2f> >& candidates, vector<vector<Point> >& contours) {
|
||||
/// 1. DETECT FIRST SET OF CANDIDATES
|
||||
_detectInitialCandidates(grey, candidates, contours, detectorParams);
|
||||
/// 2. SORT CORNERS
|
||||
_reorderCandidatesCorners(candidates);
|
||||
}
|
||||
|
||||
float getAverageArucoPinSize(vector<Point2f> markerCorners) {
|
||||
float averageArucoModuleSize = 0.f;
|
||||
int numPins = dictionary.markerSize + detectorParams.markerBorderBits * 2;
|
||||
for (size_t i = 0ull; i < markerCorners.size(); i++) {
|
||||
averageArucoModuleSize += sqrt(normL2Sqr<float>(Point2f(markerCorners[i] - markerCorners[(i+1ull)%markerCorners.size()])));
|
||||
/**
|
||||
* @brief FILTER OUT NEAR CANDIDATE PAIRS
|
||||
*
|
||||
* save the outter/inner border (i.e. potential candidates) to vector<MarkerCandidateTree>,
|
||||
* clear candidates and contours
|
||||
*/
|
||||
vector<MarkerCandidateTree>
|
||||
filterTooCloseCandidates(vector<vector<Point2f> > &candidates, vector<vector<Point> > &contours) {
|
||||
CV_Assert(detectorParams.minMarkerDistanceRate >= 0.);
|
||||
vector<MarkerCandidateTree> candidateTree(candidates.size());
|
||||
for(size_t i = 0ull; i < candidates.size(); i++) {
|
||||
candidateTree[i] = MarkerCandidateTree(std::move(candidates[i]), std::move(contours[i]));
|
||||
}
|
||||
averageArucoModuleSize /= ((float)markerCorners.size()*numPins);
|
||||
return averageArucoModuleSize;
|
||||
}
|
||||
candidates.clear();
|
||||
contours.clear();
|
||||
|
||||
// sort candidates from big to small
|
||||
std::sort(candidateTree.begin(), candidateTree.end());
|
||||
// group index for each candidate
|
||||
vector<int> groupId(candidateTree.size(), -1);
|
||||
vector<vector<size_t> > groupedCandidates;
|
||||
vector<bool> isSelectedContours(candidateTree.size(), true);
|
||||
|
||||
size_t countSelectedContours = 0ull;
|
||||
for (size_t i = 0ull; i < candidateTree.size(); i++) {
|
||||
for (size_t j = i + 1ull; j < candidateTree.size(); j++) {
|
||||
float minDist = getAverageDistance(candidateTree[i].corners, candidateTree[j].corners);
|
||||
// if mean distance is too low, group markers
|
||||
// the distance between the points of two independent markers should be more than half the side of the marker
|
||||
// half the side of the marker = (perimeter / 4) * 0.5 = perimeter * 0.125
|
||||
if(minDist < candidateTree[j].perimeter*(float)detectorParams.minMarkerDistanceRate) {
|
||||
isSelectedContours[i] = false;
|
||||
isSelectedContours[j] = false;
|
||||
// i and j are not related to a group
|
||||
if(groupId[i] < 0 && groupId[j] < 0){
|
||||
// mark candidates with their corresponding group number
|
||||
groupId[i] = groupId[j] = (int)groupedCandidates.size();
|
||||
// create group
|
||||
groupedCandidates.push_back({i, j});
|
||||
}
|
||||
// i is related to a group
|
||||
else if(groupId[i] > -1 && groupId[j] == -1) {
|
||||
int group = groupId[i];
|
||||
groupId[j] = group;
|
||||
// add to group
|
||||
groupedCandidates[group].push_back(j);
|
||||
}
|
||||
// j is related to a group
|
||||
else if(groupId[j] > -1 && groupId[i] == -1) {
|
||||
int group = groupId[j];
|
||||
groupId[i] = group;
|
||||
// add to group
|
||||
groupedCandidates[group].push_back(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
countSelectedContours += isSelectedContours[i];
|
||||
}
|
||||
|
||||
for (vector<size_t>& grouped : groupedCandidates) {
|
||||
if (detectorParams.detectInvertedMarker) // if detectInvertedMarker choose smallest contours
|
||||
std::sort(grouped.begin(), grouped.end(), [](const size_t &a, const size_t &b) {
|
||||
return a > b;
|
||||
});
|
||||
else // if detectInvertedMarker==false choose largest contours
|
||||
std::sort(grouped.begin(), grouped.end());
|
||||
size_t currId = grouped[0];
|
||||
isSelectedContours[currId] = true;
|
||||
for (size_t i = 1ull; i < grouped.size(); i++) {
|
||||
size_t id = grouped[i];
|
||||
float dist = getAverageDistance(candidateTree[id].corners, candidateTree[currId].corners);
|
||||
float moduleSize = getAverageModuleSize(candidateTree[id].corners, dictionary.markerSize, detectorParams.markerBorderBits);
|
||||
if (dist > detectorParams.minGroupDistance*moduleSize) {
|
||||
currId = id;
|
||||
candidateTree[grouped[0]].closeContours.push_back(candidateTree[id]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
vector<MarkerCandidateTree> selectedCandidates(countSelectedContours + groupedCandidates.size());
|
||||
countSelectedContours = 0ull;
|
||||
for (size_t i = 0ull; i < candidateTree.size(); i++) {
|
||||
if (isSelectedContours[i]) {
|
||||
selectedCandidates[countSelectedContours] = std::move(candidateTree[i]);
|
||||
countSelectedContours++;
|
||||
}
|
||||
}
|
||||
|
||||
// find hierarchy in the candidate tree
|
||||
for (int i = (int)selectedCandidates.size()-1; i >= 0; i--) {
|
||||
for (int j = i - 1; j >= 0; j--) {
|
||||
if (checkMarker1InMarker2(selectedCandidates[i].corners, selectedCandidates[j].corners)) {
|
||||
selectedCandidates[i].parent = j;
|
||||
selectedCandidates[j].depth = max(selectedCandidates[j].depth, selectedCandidates[i].depth + 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return selectedCandidates;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Identify square candidates according to a marker dictionary
|
||||
*/
|
||||
void identifyCandidates(const Mat& grey, const vector<Mat>& image_pyr, vector<MarkerCandidateTree>& selectedContours,
|
||||
vector<vector<Point2f> >& accepted, vector<vector<Point> >& contours,
|
||||
vector<int>& ids, OutputArrayOfArrays _rejected = noArray()) {
|
||||
size_t ncandidates = selectedContours.size();
|
||||
vector<vector<Point2f> > rejected;
|
||||
|
||||
vector<int> idsTmp(ncandidates, -1);
|
||||
vector<int> rotated(ncandidates, 0);
|
||||
vector<uint8_t> validCandidates(ncandidates, 0);
|
||||
vector<bool> was(ncandidates, false);
|
||||
bool checkCloseContours = true;
|
||||
|
||||
int maxDepth = 0;
|
||||
for (size_t i = 0ull; i < selectedContours.size(); i++)
|
||||
maxDepth = max(selectedContours[i].depth, maxDepth);
|
||||
vector<vector<size_t>> depths(maxDepth+1);
|
||||
for (size_t i = 0ull; i < selectedContours.size(); i++) {
|
||||
depths[selectedContours[i].depth].push_back(i);
|
||||
}
|
||||
|
||||
//// Analyze each of the candidates
|
||||
int depth = 0;
|
||||
size_t counter = 0;
|
||||
while (counter < ncandidates) {
|
||||
parallel_for_(Range(0, (int)depths[depth].size()), [&](const Range& range) {
|
||||
const int begin = range.start;
|
||||
const int end = range.end;
|
||||
for (int i = begin; i < end; i++) {
|
||||
size_t v = depths[depth][i];
|
||||
was[v] = true;
|
||||
Mat img = grey;
|
||||
// implements equation (4)
|
||||
if (detectorParams.useAruco3Detection) {
|
||||
const int minPerimeter = detectorParams.minSideLengthCanonicalImg * 4;
|
||||
const size_t nearestImgId = _findOptPyrImageForCanonicalImg(image_pyr, grey.cols, static_cast<int>(selectedContours[v].contour.size()), minPerimeter);
|
||||
img = image_pyr[nearestImgId];
|
||||
}
|
||||
const float scale = detectorParams.useAruco3Detection ? img.cols / static_cast<float>(grey.cols) : 1.f;
|
||||
|
||||
validCandidates[v] = _identifyOneCandidate(dictionary, img, selectedContours[v].corners, idsTmp[v], detectorParams, rotated[v], scale);
|
||||
|
||||
if (validCandidates[v] == 0 && checkCloseContours) {
|
||||
for (const MarkerCandidate& closeMarkerCandidate: selectedContours[v].closeContours) {
|
||||
validCandidates[v] = _identifyOneCandidate(dictionary, img, closeMarkerCandidate.corners, idsTmp[v], detectorParams, rotated[v], scale);
|
||||
if (validCandidates[v] > 0) {
|
||||
selectedContours[v].corners = closeMarkerCandidate.corners;
|
||||
selectedContours[v].contour = closeMarkerCandidate.contour;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// visit the parent vertices of the detected markers to skip identify parent contours
|
||||
for(size_t v : depths[depth]) {
|
||||
if(validCandidates[v] > 0) {
|
||||
int parent = selectedContours[v].parent;
|
||||
while (parent != -1) {
|
||||
if (!was[parent]) {
|
||||
was[parent] = true;
|
||||
counter++;
|
||||
}
|
||||
parent = selectedContours[parent].parent;
|
||||
}
|
||||
}
|
||||
counter++;
|
||||
}
|
||||
depth++;
|
||||
}
|
||||
|
||||
for (size_t i = 0ull; i < selectedContours.size(); i++) {
|
||||
if (validCandidates[i] > 0) {
|
||||
// shift corner positions to the correct rotation
|
||||
correctCornerPosition(selectedContours[i].corners, rotated[i]);
|
||||
|
||||
accepted.push_back(selectedContours[i].corners);
|
||||
contours.push_back(selectedContours[i].contour);
|
||||
ids.push_back(idsTmp[i]);
|
||||
}
|
||||
else {
|
||||
rejected.push_back(selectedContours[i].corners);
|
||||
}
|
||||
}
|
||||
|
||||
// parse output
|
||||
if(_rejected.needed()) {
|
||||
_copyVector2Output(rejected, _rejected);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
@@ -929,23 +934,21 @@ void ArucoDetector::detectMarkers(InputArray _image, OutputArrayOfArrays _corner
|
||||
vector<vector<Point> > contours;
|
||||
vector<int> ids;
|
||||
|
||||
vector<vector<vector<Point2f> > > candidatesSet;
|
||||
vector<vector<vector<Point> > > contoursSet;
|
||||
|
||||
/// STEP 2.a Detect marker candidates :: using AprilTag
|
||||
if(detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_APRILTAG){
|
||||
_apriltag(grey, detectorParams, candidates, contours);
|
||||
|
||||
candidatesSet.push_back(candidates);
|
||||
contoursSet.push_back(contours);
|
||||
}
|
||||
/// STEP 2.b Detect marker candidates :: traditional way
|
||||
else
|
||||
_detectCandidates(grey, candidatesSet, contoursSet, detectorParams);
|
||||
else {
|
||||
arucoDetectorImpl->detectCandidates(grey, candidates, contours);
|
||||
}
|
||||
|
||||
/// STEP 2.c FILTER OUT NEAR CANDIDATE PAIRS
|
||||
auto selectedCandidates = arucoDetectorImpl->filterTooCloseCandidates(candidates, contours);
|
||||
|
||||
/// STEP 2: Check candidate codification (identify markers)
|
||||
_identifyCandidates(grey, grey_pyramid, candidatesSet, contoursSet, dictionary,
|
||||
candidates, contours, ids, detectorParams, _rejectedImgPoints);
|
||||
arucoDetectorImpl->identifyCandidates(grey, grey_pyramid, selectedCandidates, candidates, contours,
|
||||
ids, _rejectedImgPoints);
|
||||
|
||||
/// STEP 3: Corner refinement :: use corner subpix
|
||||
if (detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_SUBPIX) {
|
||||
@@ -963,7 +966,7 @@ void ArucoDetector::detectMarkers(InputArray _image, OutputArrayOfArrays _corner
|
||||
}
|
||||
else {
|
||||
int cornerRefinementWinSize = std::max(1, cvRound(detectorParams.relativeCornerRefinmentWinSize*
|
||||
arucoDetectorImpl->getAverageArucoPinSize(candidates[i])));
|
||||
getAverageModuleSize(candidates[i], dictionary.markerSize, detectorParams.markerBorderBits)));
|
||||
cornerRefinementWinSize = min(cornerRefinementWinSize, detectorParams.cornerRefinementWinSize);
|
||||
cornerSubPix(grey, Mat(candidates[i]), Size(cornerRefinementWinSize, cornerRefinementWinSize), Size(-1, -1),
|
||||
TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
|
||||
@@ -1238,7 +1241,7 @@ void ArucoDetector::refineDetectedMarkers(InputArray _image, const Board& _board
|
||||
|
||||
std::vector<Point2f> marker(closestRotatedMarker.begin<Point2f>(), closestRotatedMarker.end<Point2f>());
|
||||
int cornerRefinementWinSize = std::max(1, cvRound(detectorParams.relativeCornerRefinmentWinSize*
|
||||
arucoDetectorImpl->getAverageArucoPinSize(marker)));
|
||||
getAverageModuleSize(marker, dictionary.markerSize, detectorParams.markerBorderBits)));
|
||||
cornerRefinementWinSize = min(cornerRefinementWinSize, detectorParams.cornerRefinementWinSize);
|
||||
cornerSubPix(grey, closestRotatedMarker,
|
||||
Size(cornerRefinementWinSize, cornerRefinementWinSize),
|
||||
|
||||
@@ -314,7 +314,9 @@ struct CharucoDetector::CharucoDetectorImpl {
|
||||
vector<vector<Point2f> > rejectedMarkers;
|
||||
arucoDetector.detectMarkers(image, _markerCorners, _markerIds, rejectedMarkers);
|
||||
if (charucoParameters.tryRefineMarkers)
|
||||
arucoDetector.refineDetectedMarkers(image, board, _markerCorners, _markerIds, rejectedMarkers);
|
||||
arucoDetector.refineDetectedMarkers(image, board, _markerCorners, _markerIds, rejectedMarkers);
|
||||
if (_markerCorners.empty() && _markerIds.empty())
|
||||
return;
|
||||
}
|
||||
// if camera parameters are avaible, use approximated calibration
|
||||
if(!charucoParameters.cameraMatrix.empty())
|
||||
|
||||
@@ -48,6 +48,35 @@ public:
|
||||
topK = top_k;
|
||||
}
|
||||
|
||||
FaceDetectorYNImpl(const String& framework,
|
||||
const std::vector<uchar>& bufferModel,
|
||||
const std::vector<uchar>& bufferConfig,
|
||||
const Size& input_size,
|
||||
float score_threshold,
|
||||
float nms_threshold,
|
||||
int top_k,
|
||||
int backend_id,
|
||||
int target_id)
|
||||
:divisor(32),
|
||||
strides({8, 16, 32})
|
||||
{
|
||||
net = dnn::readNet(framework, bufferModel, bufferConfig);
|
||||
CV_Assert(!net.empty());
|
||||
|
||||
net.setPreferableBackend(backend_id);
|
||||
net.setPreferableTarget(target_id);
|
||||
|
||||
inputW = input_size.width;
|
||||
inputH = input_size.height;
|
||||
|
||||
padW = (int((inputW - 1) / divisor) + 1) * divisor;
|
||||
padH = (int((inputH - 1) / divisor) + 1) * divisor;
|
||||
|
||||
scoreThreshold = score_threshold;
|
||||
nmsThreshold = nms_threshold;
|
||||
topK = top_k;
|
||||
}
|
||||
|
||||
void setInputSize(const Size& input_size) override
|
||||
{
|
||||
inputW = input_size.width;
|
||||
@@ -264,4 +293,22 @@ Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& model,
|
||||
#endif
|
||||
}
|
||||
|
||||
Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& framework,
|
||||
const std::vector<uchar>& bufferModel,
|
||||
const std::vector<uchar>& bufferConfig,
|
||||
const Size& input_size,
|
||||
const float score_threshold,
|
||||
const float nms_threshold,
|
||||
const int top_k,
|
||||
const int backend_id,
|
||||
const int target_id)
|
||||
{
|
||||
#ifdef HAVE_OPENCV_DNN
|
||||
return makePtr<FaceDetectorYNImpl>(framework, bufferModel, bufferConfig, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id);
|
||||
#else
|
||||
CV_UNUSED(bufferModel); CV_UNUSED(bufferConfig); CV_UNUSED(input_size); CV_UNUSED(score_threshold); CV_UNUSED(nms_threshold); CV_UNUSED(top_k); CV_UNUSED(backend_id); CV_UNUSED(target_id);
|
||||
CV_Error(cv::Error::StsNotImplemented, "cv::FaceDetectorYN requires enabled 'dnn' module.");
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace cv
|
||||
|
||||
@@ -20,6 +20,18 @@ struct GraphicalCodeDetector::Impl {
|
||||
OutputArray points, OutputArrayOfArrays straight_code) const = 0;
|
||||
};
|
||||
|
||||
class QRCodeDecoder {
|
||||
public:
|
||||
virtual ~QRCodeDecoder();
|
||||
|
||||
static Ptr<QRCodeDecoder> create();
|
||||
|
||||
virtual bool decode(const Mat& straight, String& decoded_info) = 0;
|
||||
|
||||
QRCodeEncoder::EncodeMode mode;
|
||||
QRCodeEncoder::ECIEncodings eci;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -2728,7 +2728,6 @@ bool QRDecode::samplingForVersion()
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static bool checkASCIIcompatible(const uint8_t* str, const size_t size) {
|
||||
for (size_t i = 0; i < size; ++i) {
|
||||
uint8_t byte = str[i];
|
||||
@@ -2782,6 +2781,10 @@ static std::string encodeUTF8_bytesarray(const uint8_t* str, const size_t size)
|
||||
|
||||
bool QRDecode::decodingProcess()
|
||||
{
|
||||
QRCodeEncoder::EncodeMode mode;
|
||||
QRCodeEncoder::ECIEncodings eci;
|
||||
const uint8_t* payload;
|
||||
size_t payload_len;
|
||||
#ifdef HAVE_QUIRC
|
||||
if (straight.empty()) { return false; }
|
||||
|
||||
@@ -2811,65 +2814,79 @@ bool QRDecode::decodingProcess()
|
||||
|
||||
CV_LOG_INFO(NULL, "QR: decoded with .version=" << qr_code_data.version << " .data_type=" << qr_code_data.data_type << " .eci=" << qr_code_data.eci << " .payload_len=" << qr_code_data.payload_len)
|
||||
|
||||
switch (qr_code_data.data_type)
|
||||
mode = static_cast<QRCodeEncoder::EncodeMode>(qr_code_data.data_type);
|
||||
eci = static_cast<QRCodeEncoder::ECIEncodings>(qr_code_data.eci);
|
||||
payload = qr_code_data.payload;
|
||||
payload_len = qr_code_data.payload_len;
|
||||
#else
|
||||
auto decoder = QRCodeDecoder::create();
|
||||
if (!decoder->decode(straight, result_info))
|
||||
return false;
|
||||
mode = decoder->mode;
|
||||
eci = decoder->eci;
|
||||
payload = reinterpret_cast<const uint8_t*>(result_info.c_str());
|
||||
payload_len = result_info.size();
|
||||
#endif
|
||||
|
||||
// Check output string format
|
||||
switch (mode)
|
||||
{
|
||||
case QUIRC_DATA_TYPE_NUMERIC:
|
||||
if (!checkASCIIcompatible(qr_code_data.payload, qr_code_data.payload_len)) {
|
||||
case QRCodeEncoder::EncodeMode::MODE_NUMERIC:
|
||||
if (!checkASCIIcompatible(payload, payload_len)) {
|
||||
CV_LOG_INFO(NULL, "QR: DATA_TYPE_NUMERIC payload must be ACSII compatible string");
|
||||
return false;
|
||||
}
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
return true;
|
||||
case QUIRC_DATA_TYPE_ALPHA:
|
||||
if (!checkASCIIcompatible(qr_code_data.payload, qr_code_data.payload_len)) {
|
||||
case QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC:
|
||||
if (!checkASCIIcompatible(payload, payload_len)) {
|
||||
CV_LOG_INFO(NULL, "QR: DATA_TYPE_ALPHA payload must be ASCII compatible string");
|
||||
return false;
|
||||
}
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
return true;
|
||||
case QUIRC_DATA_TYPE_BYTE:
|
||||
case QRCodeEncoder::EncodeMode::MODE_BYTE:
|
||||
// https://en.wikipedia.org/wiki/Extended_Channel_Interpretation
|
||||
if (qr_code_data.eci == QUIRC_ECI_UTF_8) {
|
||||
if (eci == QRCodeEncoder::ECIEncodings::ECI_UTF8) {
|
||||
CV_LOG_INFO(NULL, "QR: payload ECI is UTF-8");
|
||||
if (!checkUTF8(qr_code_data.payload, qr_code_data.payload_len)) {
|
||||
if (!checkUTF8(payload, payload_len)) {
|
||||
CV_LOG_INFO(NULL, "QUIRC_DATA_TYPE_BYTE with UTF-8 ECI must be UTF-8 compatible string");
|
||||
return false;
|
||||
}
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
} else if (qr_code_data.eci == 25/*ECI_UTF_16BE*/) {
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
} else if (eci == 25/*ECI_UTF_16BE*/) {
|
||||
CV_LOG_INFO(NULL, "QR: UTF-16BE ECI is not supported");
|
||||
return false;
|
||||
} else if (checkASCIIcompatible(qr_code_data.payload, qr_code_data.payload_len)) {
|
||||
} else if (checkASCIIcompatible(payload, payload_len)) {
|
||||
CV_LOG_INFO(NULL, "QR: payload is ASCII compatible (special handling for symbols encoding is not needed)");
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
} else {
|
||||
if (checkUTF8(qr_code_data.payload, qr_code_data.payload_len)) {
|
||||
if (checkUTF8(payload, payload_len)) {
|
||||
CV_LOG_INFO(NULL, "QR: payload QUIRC_DATA_TYPE_BYTE is UTF-8 compatible, return as-is");
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
} else {
|
||||
CV_LOG_INFO(NULL, "QR: assume 1-byte per symbol encoding");
|
||||
result_info = encodeUTF8_bytesarray(qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info = encodeUTF8_bytesarray(payload, payload_len);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
case QUIRC_DATA_TYPE_KANJI:
|
||||
case QRCodeEncoder::EncodeMode::MODE_KANJI:
|
||||
// FIXIT BUG: we must return UTF-8 compatible string
|
||||
CV_LOG_WARNING(NULL, "QR: Kanji is not supported properly");
|
||||
result_info.assign((const char*)qr_code_data.payload, qr_code_data.payload_len);
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
return true;
|
||||
case QRCodeEncoder::EncodeMode::MODE_ECI:
|
||||
CV_LOG_WARNING(NULL, "QR: ECI is not supported properly");
|
||||
result_info.assign((const char*)payload, payload_len);
|
||||
return true;
|
||||
default:
|
||||
CV_LOG_WARNING(NULL, "QR: unsupported QR data type");
|
||||
return false;
|
||||
}
|
||||
|
||||
CV_LOG_WARNING(NULL, "QR: unsupported QR data type");
|
||||
return false;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
bool QRDecode::straightDecodingProcess()
|
||||
{
|
||||
#ifdef HAVE_QUIRC
|
||||
if (!updatePerspective(getHomography())) { return false; }
|
||||
if (!versionDefinition()) { return false; }
|
||||
if (useAlignmentMarkers)
|
||||
@@ -2877,24 +2894,15 @@ bool QRDecode::straightDecodingProcess()
|
||||
if (!samplingForVersion()) { return false; }
|
||||
if (!decodingProcess()) { return false; }
|
||||
return true;
|
||||
#else
|
||||
std::cout << "Library QUIRC is not linked. No decoding is performed. Take it to the OpenCV repository." << std::endl;
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool QRDecode::curvedDecodingProcess()
|
||||
{
|
||||
#ifdef HAVE_QUIRC
|
||||
if (!preparingCurvedQRCodes()) { return false; }
|
||||
if (!versionDefinition()) { return false; }
|
||||
if (!samplingForVersion()) { return false; }
|
||||
if (!decodingProcess()) { return false; }
|
||||
return true;
|
||||
#else
|
||||
std::cout << "Library QUIRC is not linked. No decoding is performed. Take it to the OpenCV repository." << std::endl;
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
QRDecode::QRDecode(bool _useAlignmentMarkers):
|
||||
@@ -4477,25 +4485,14 @@ static
|
||||
vector<QRCode> analyzeFinderPatterns(const vector<vector<Point2f> > &corners, const Mat& img,
|
||||
const QRCodeDetectorAruco::Params& qrDetectorParameters) {
|
||||
vector<QRCode> qrCodes;
|
||||
vector<FinderPatternInfo> patterns;
|
||||
vector<FinderPatternInfo> patterns(corners.size());
|
||||
if (img.empty())
|
||||
return qrCodes;
|
||||
float maxModuleSize = 0.f;
|
||||
for (size_t i = 0ull; i < corners.size(); i++) {
|
||||
FinderPatternInfo pattern = FinderPatternInfo(corners[i]);
|
||||
// TODO: improve thinning Aruco markers
|
||||
bool isUniq = true;
|
||||
for (const FinderPatternInfo& tmp : patterns) {
|
||||
Point2f dist = pattern.center - tmp.center;
|
||||
if (max(abs(dist.x), abs(dist.y)) < 3.f * tmp.moduleSize) {
|
||||
isUniq = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (isUniq) {
|
||||
patterns.push_back(pattern);
|
||||
maxModuleSize = max(maxModuleSize, patterns.back().moduleSize);
|
||||
}
|
||||
patterns[i] = pattern;
|
||||
maxModuleSize = max(maxModuleSize, pattern.moduleSize);
|
||||
}
|
||||
const int threshold = cvRound(qrDetectorParameters.minModuleSizeInPyramid * 12.5f) +
|
||||
(cvRound(qrDetectorParameters.minModuleSizeInPyramid * 12.5f) % 2 ? 0 : 1);
|
||||
|
||||
@@ -6,6 +6,8 @@
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "qrcode_encoder_table.inl.hpp"
|
||||
#include "graphical_code_detector_impl.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
using std::vector;
|
||||
@@ -19,6 +21,7 @@ const uint8_t INVALID_REGION_VALUE = 110;
|
||||
static void decToBin(const int dec_number, const int total_bits, std::vector<uint8_t> &bin_number);
|
||||
static uint8_t gfPow(uint8_t x, int power);
|
||||
static uint8_t gfMul(const uint8_t x, const uint8_t y);
|
||||
static uint8_t gfDiv(const uint8_t x, const uint8_t y);
|
||||
static void gfPolyMul(const vector<uint8_t> &p, const vector<uint8_t> &q, vector<uint8_t> &product);
|
||||
static void gfPolyDiv(const vector<uint8_t> ÷nd, const vector<uint8_t> &divisor, const int ecc_num, vector<uint8_t> "ient);
|
||||
static void polyGenerator(const int n, vector<uint8_t> &result);
|
||||
@@ -51,6 +54,13 @@ static uint8_t gfMul(const uint8_t x, const uint8_t y)
|
||||
return gf_exp[(gf_log[x] + gf_log[y]) % 255];
|
||||
}
|
||||
|
||||
static uint8_t gfDiv(const uint8_t x, const uint8_t y)
|
||||
{
|
||||
if (x == 0 || y == 0)
|
||||
return 0;
|
||||
return gf_exp[(gf_log[x] + 255 - gf_log[y]) % 255];
|
||||
}
|
||||
|
||||
static void gfPolyMul(const vector<uint8_t> &p, const vector<uint8_t> &q, vector<uint8_t> &product)
|
||||
{
|
||||
int len_p = (int)p.size();
|
||||
@@ -141,6 +151,8 @@ static int mapSymbol(char c)
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void maskData(const Mat& original, const int mask_type_num, Mat &masked);
|
||||
|
||||
QRCodeEncoder::QRCodeEncoder()
|
||||
{
|
||||
// nothing
|
||||
@@ -196,17 +208,18 @@ protected:
|
||||
uint8_t total_num;
|
||||
vector<Mat> final_qrcodes;
|
||||
|
||||
Ptr<VersionInfo> version_info;
|
||||
Ptr<BlockParams> cur_ecc_params;
|
||||
const VersionInfo* version_info;
|
||||
const BlockParams* cur_ecc_params;
|
||||
|
||||
bool isNumeric(const std::string& input);
|
||||
bool isAlphaNumeric(const std::string& input);
|
||||
bool isNumeric(const std::string& input) const;
|
||||
bool isAlphaNumeric(const std::string& input) const;
|
||||
EncodeMode autoEncodeMode(const std::string &input) const ;
|
||||
bool encodeByte(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeAlpha(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeNumeric(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeECI(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeKanji(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeAuto(const std::string& input, vector<uint8_t> &output);
|
||||
bool encodeAuto(const std::string& input, vector<uint8_t> &output, EncodeMode *mode = nullptr);
|
||||
bool encodeStructure(const std::string& input, vector<uint8_t> &output);
|
||||
int eccLevelToCode(CorrectionLevel level);
|
||||
void padBitStream();
|
||||
@@ -220,11 +233,10 @@ protected:
|
||||
void formatGenerate(const int mask_type_num, vector<uint8_t> &format_array);
|
||||
void versionInfoGenerate(const int version_level_num, vector<uint8_t> &version_array);
|
||||
void fillReserved(const vector<uint8_t> &format_array, Mat &masked);
|
||||
void maskData(const int mask_type_num, Mat &masked);
|
||||
void findAutoMaskType();
|
||||
bool estimateVersion(const int input_length, vector<int> &possible_version);
|
||||
bool estimateVersion(const int input_length, EncodeMode mode, vector<int> &possible_version);
|
||||
int versionAuto(const std::string &input_str);
|
||||
int findVersionCapacity(const int input_length, const int ecc, const int version_begin, const int version_end);
|
||||
int findVersionCapacity(const int input_length, const int ecc, const std::vector<int>& possible_versions);
|
||||
void generatingProcess(const std::string& input, Mat &qrcode);
|
||||
void generateQR(const std::string& input);
|
||||
};
|
||||
@@ -247,17 +259,17 @@ int QRCodeEncoderImpl::eccLevelToCode(CorrectionLevel level)
|
||||
"CORRECT_LEVEL_L, CORRECT_LEVEL_M, CORRECT_LEVEL_Q, CORRECT_LEVEL_H." );
|
||||
}
|
||||
|
||||
int QRCodeEncoderImpl::findVersionCapacity(const int input_length, const int ecc, const int version_begin, const int version_end)
|
||||
int QRCodeEncoderImpl::findVersionCapacity(const int input_length, const int ecc, const std::vector<int>& possible_versions)
|
||||
{
|
||||
int data_codewords, version_index = -1;
|
||||
const int byte_len = 8;
|
||||
version_index = -1;
|
||||
|
||||
for (int i = version_begin; i < version_end; i++)
|
||||
for (int i : possible_versions)
|
||||
{
|
||||
Ptr<BlockParams> tmp_ecc_params = makePtr<BlockParams>(version_info_database[i].ecc[ecc]);
|
||||
data_codewords = tmp_ecc_params->data_codewords_in_G1 * tmp_ecc_params->num_blocks_in_G1 +
|
||||
tmp_ecc_params->data_codewords_in_G2 * tmp_ecc_params->num_blocks_in_G2;
|
||||
auto& tmp_ecc_params = version_info_database[i].ecc[ecc];
|
||||
data_codewords = tmp_ecc_params.data_codewords_in_G1 * tmp_ecc_params.num_blocks_in_G1 +
|
||||
tmp_ecc_params.data_codewords_in_G2 * tmp_ecc_params.num_blocks_in_G2;
|
||||
|
||||
if (data_codewords * byte_len >= input_length)
|
||||
{
|
||||
@@ -268,53 +280,70 @@ int QRCodeEncoderImpl::findVersionCapacity(const int input_length, const int ecc
|
||||
return version_index;
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::estimateVersion(const int input_length, vector<int>& possible_version)
|
||||
static inline int getCapacity(int version, QRCodeEncoder::CorrectionLevel ecc_level, QRCodeEncoder::EncodeMode mode) {
|
||||
const int* capacity = version_capacity_database[version].ec_level[ecc_level].encoding_modes;
|
||||
switch (mode) {
|
||||
case QRCodeEncoder::EncodeMode::MODE_NUMERIC:
|
||||
return capacity[0];
|
||||
case QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC:
|
||||
return capacity[1];
|
||||
case QRCodeEncoder::EncodeMode::MODE_BYTE:
|
||||
return capacity[2];
|
||||
case QRCodeEncoder::EncodeMode::MODE_KANJI:
|
||||
return capacity[3];
|
||||
default:
|
||||
CV_Error(Error::StsNotImplemented, format("Unexpected mode %d", mode));
|
||||
}
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::estimateVersion(const int input_length, EncodeMode mode, vector<int>& possible_version)
|
||||
{
|
||||
possible_version.clear();
|
||||
if (input_length > version_capacity_database[40].ec_level[ecc_level].encoding_modes[1])
|
||||
|
||||
CV_Assert(mode != EncodeMode::MODE_AUTO);
|
||||
|
||||
if (input_length > getCapacity(MAX_VERSION, ecc_level, mode))
|
||||
{
|
||||
return false;
|
||||
if (input_length <= version_capacity_database[9].ec_level[ecc_level].encoding_modes[3])
|
||||
{
|
||||
possible_version.push_back(1);
|
||||
}
|
||||
else if (input_length <= version_capacity_database[9].ec_level[ecc_level].encoding_modes[1])
|
||||
|
||||
int version = MAX_VERSION;
|
||||
|
||||
for (; version > 0; --version)
|
||||
{
|
||||
possible_version.push_back(1);
|
||||
possible_version.push_back(2);
|
||||
if (input_length > getCapacity(version, ecc_level, mode)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (input_length <= version_capacity_database[26].ec_level[ecc_level].encoding_modes[3])
|
||||
|
||||
if (version < MAX_VERSION)
|
||||
{
|
||||
possible_version.push_back(2);
|
||||
version += 1;
|
||||
}
|
||||
else if (input_length <= version_capacity_database[26].ec_level[ecc_level].encoding_modes[1])
|
||||
|
||||
possible_version.push_back(version);
|
||||
|
||||
if (version < MAX_VERSION)
|
||||
{
|
||||
possible_version.push_back(2);
|
||||
possible_version.push_back(3);
|
||||
}
|
||||
else
|
||||
{
|
||||
possible_version.push_back(3);
|
||||
possible_version.push_back(version + 1);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int QRCodeEncoderImpl::versionAuto(const std::string& input_str)
|
||||
{
|
||||
vector<int> possible_version;
|
||||
estimateVersion((int)input_str.length(), possible_version);
|
||||
int tmp_version = 0;
|
||||
vector<uint8_t> payload_tmp;
|
||||
int version_range[5] = {0, 1, 10, 27, 41};
|
||||
for(size_t i = 0; i < possible_version.size(); i++)
|
||||
{
|
||||
int version_range_index = possible_version[i];
|
||||
EncodeMode mode;
|
||||
encodeAuto(input_str, payload_tmp, &mode);
|
||||
|
||||
encodeAuto(input_str, payload_tmp);
|
||||
tmp_version = findVersionCapacity((int)payload_tmp.size(), ecc_level,
|
||||
version_range[version_range_index], version_range[version_range_index + 1]);
|
||||
if(tmp_version != -1)
|
||||
break;
|
||||
vector<int> possible_version;
|
||||
if (!estimateVersion((int)input_str.length(), mode, possible_version)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
const auto tmp_version = findVersionCapacity((int)payload_tmp.size(), ecc_level, possible_version);
|
||||
|
||||
return tmp_version;
|
||||
}
|
||||
|
||||
@@ -342,20 +371,23 @@ void QRCodeEncoderImpl::generateQR(const std::string &input)
|
||||
|
||||
std::string input_info = input.substr(segment_begin, segment_end);
|
||||
string_itr += segment_end;
|
||||
|
||||
int detected_version = versionAuto(input_info);
|
||||
CV_Assert(detected_version != -1);
|
||||
if (version_level == 0)
|
||||
version_level = detected_version;
|
||||
else if (version_level < detected_version)
|
||||
int tmp_version_level = version_level;
|
||||
if (detected_version == -1)
|
||||
CV_Error(Error::StsBadArg, "The given input exceeds the maximum capacity of a QR code with the selected encoding mode and error correction level " );
|
||||
else if (tmp_version_level == 0)
|
||||
tmp_version_level = detected_version;
|
||||
else if (tmp_version_level < detected_version)
|
||||
CV_Error(Error::StsBadArg, "The given version is not suitable for the given input string length ");
|
||||
|
||||
payload.clear();
|
||||
payload.reserve(MAX_PAYLOAD_LEN);
|
||||
format = vector<uint8_t> (15, 255);
|
||||
version_reserved = vector<uint8_t> (18, 255);
|
||||
version_size = (21 + (version_level - 1) * 4);
|
||||
version_info = makePtr<VersionInfo>(version_info_database[version_level]);
|
||||
cur_ecc_params = makePtr<BlockParams>(version_info->ecc[ecc_level]);
|
||||
version_size = (21 + (tmp_version_level - 1) * 4);
|
||||
version_info = &version_info_database[tmp_version_level];
|
||||
cur_ecc_params = &version_info->ecc[ecc_level];
|
||||
original = Mat(Size(version_size, version_size), CV_8UC1, Scalar(255));
|
||||
masked_data = original.clone();
|
||||
Mat qrcode = masked_data.clone();
|
||||
@@ -366,36 +398,10 @@ void QRCodeEncoderImpl::generateQR(const std::string &input)
|
||||
|
||||
void QRCodeEncoderImpl::formatGenerate(const int mask_type_num, vector<uint8_t> &format_array)
|
||||
{
|
||||
const int mask_bits_num = 3;
|
||||
const int level_bits_num = 2;
|
||||
|
||||
std::vector<uint8_t> mask_type_bin(mask_bits_num);
|
||||
std::vector<uint8_t> ec_level_bin(level_bits_num);
|
||||
decToBin(mask_type_num, mask_bits_num, mask_type_bin);
|
||||
decToBin(eccLevelToCode(ecc_level), level_bits_num, ec_level_bin);
|
||||
|
||||
std::vector<uint8_t> format_bits;
|
||||
hconcat(ec_level_bin, mask_type_bin, format_bits);
|
||||
std::reverse(format_bits.begin(), format_bits.end());
|
||||
|
||||
const int ecc_info_bits = 10;
|
||||
|
||||
std::vector<uint8_t> shift(ecc_info_bits, 0);
|
||||
std::vector<uint8_t> polynomial;
|
||||
hconcat(shift, format_bits, polynomial);
|
||||
|
||||
const int generator_len = 11;
|
||||
const uint8_t generator_arr[generator_len] = {1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1};
|
||||
std::vector<uint8_t> format_generator (generator_arr, generator_arr + sizeof(generator_arr) / sizeof(generator_arr[0]));
|
||||
vector<uint8_t> ecc_code;
|
||||
gfPolyDiv(polynomial, format_generator, ecc_info_bits, ecc_code);
|
||||
hconcat(ecc_code, format_bits, format_array);
|
||||
|
||||
const uint8_t mask_arr[MAX_FORMAT_LENGTH] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1};
|
||||
std::vector<uint8_t> system_mask (mask_arr, mask_arr + sizeof(mask_arr) / sizeof(mask_arr[0]));
|
||||
for(int i = 0; i < MAX_FORMAT_LENGTH; i++)
|
||||
{
|
||||
format_array[i] ^= system_mask[i];
|
||||
int idx = (eccLevelToCode(ecc_level) << 3) | mask_type_num;
|
||||
format_array.resize(MAX_FORMAT_LENGTH);
|
||||
for (int i = 0; i < MAX_FORMAT_LENGTH; ++i) {
|
||||
format_array[i] = (formatInfoLUT[idx] >> i) & 1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -613,7 +619,7 @@ bool QRCodeEncoderImpl::encodeStructure(const std::string& input, vector<uint8_t
|
||||
return encodeAuto(input, output);
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::isNumeric(const std::string& input)
|
||||
bool QRCodeEncoderImpl::isNumeric(const std::string& input) const
|
||||
{
|
||||
for (size_t i = 0; i < input.length(); i++)
|
||||
{
|
||||
@@ -623,7 +629,7 @@ bool QRCodeEncoderImpl::isNumeric(const std::string& input)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::isAlphaNumeric(const std::string& input)
|
||||
bool QRCodeEncoderImpl::isAlphaNumeric(const std::string& input) const
|
||||
{
|
||||
for (size_t i = 0; i < input.length(); i++)
|
||||
{
|
||||
@@ -633,14 +639,56 @@ bool QRCodeEncoderImpl::isAlphaNumeric(const std::string& input)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::encodeAuto(const std::string& input, vector<uint8_t>& output)
|
||||
QRCodeEncoder::EncodeMode QRCodeEncoderImpl::autoEncodeMode(const std::string &input) const
|
||||
{
|
||||
if (isNumeric(input))
|
||||
encodeNumeric(input, output);
|
||||
else if (isAlphaNumeric(input))
|
||||
encodeAlpha(input, output);
|
||||
else
|
||||
encodeByte(input, output);
|
||||
{
|
||||
return EncodeMode::MODE_NUMERIC;
|
||||
}
|
||||
|
||||
if (isAlphaNumeric(input))
|
||||
{
|
||||
return EncodeMode::MODE_ALPHANUMERIC;
|
||||
}
|
||||
|
||||
return EncodeMode::MODE_BYTE;
|
||||
}
|
||||
|
||||
bool QRCodeEncoderImpl::encodeAuto(const std::string& input, vector<uint8_t>& output, EncodeMode *mode)
|
||||
{
|
||||
const auto selected_mode = autoEncodeMode(input);
|
||||
|
||||
CV_Assert(selected_mode != EncodeMode::MODE_AUTO);
|
||||
|
||||
switch (selected_mode)
|
||||
{
|
||||
case EncodeMode::MODE_NUMERIC:
|
||||
encodeNumeric(input, output);
|
||||
break;
|
||||
case EncodeMode::MODE_ALPHANUMERIC:
|
||||
encodeAlpha(input, output);
|
||||
break;
|
||||
case EncodeMode::MODE_STRUCTURED_APPEND:
|
||||
encodeByte(input, output);
|
||||
break;
|
||||
case EncodeMode::MODE_BYTE:
|
||||
encodeByte(input, output);
|
||||
break;
|
||||
case EncodeMode::MODE_KANJI:
|
||||
encodeKanji(input, output);
|
||||
break;
|
||||
case EncodeMode::MODE_ECI:
|
||||
encodeECI(input, output);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (mode != nullptr)
|
||||
{
|
||||
*mode = selected_mode;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -787,7 +835,7 @@ void QRCodeEncoderImpl::findAutoMaskType()
|
||||
{
|
||||
Mat test_result = masked_data.clone();
|
||||
vector<uint8_t> test_format = format;
|
||||
maskData(cur_type, test_result);
|
||||
maskData(original, cur_type, test_result);
|
||||
formatGenerate(cur_type, test_format);
|
||||
fillReserved(test_format, test_result);
|
||||
int continued_num = 0;
|
||||
@@ -899,8 +947,9 @@ void QRCodeEncoderImpl::findAutoMaskType()
|
||||
mask_type = best_index;
|
||||
}
|
||||
|
||||
void QRCodeEncoderImpl::maskData(const int mask_type_num, Mat& masked)
|
||||
void maskData(const Mat& original, const int mask_type_num, Mat& masked)
|
||||
{
|
||||
int version_size = original.rows;
|
||||
for (int i = 0; i < version_size; i++)
|
||||
{
|
||||
for (int j = 0; j < version_size; j++)
|
||||
@@ -1204,7 +1253,7 @@ void QRCodeEncoderImpl::structureFinalMessage()
|
||||
writeReservedArea();
|
||||
writeData();
|
||||
findAutoMaskType();
|
||||
maskData(mask_type, masked_data);
|
||||
maskData(original, mask_type, masked_data);
|
||||
formatGenerate(mask_type, format);
|
||||
versionInfoGenerate(version_level, version_reserved);
|
||||
fillReserved(format, masked_data);
|
||||
@@ -1260,4 +1309,521 @@ Ptr<QRCodeEncoder> QRCodeEncoder::create(const QRCodeEncoder::Params& parameters
|
||||
return makePtr<QRCodeEncoderImpl>(parameters);
|
||||
}
|
||||
|
||||
class QRCodeDecoderImpl : public QRCodeDecoder {
|
||||
public:
|
||||
bool decode(const Mat& straight, String& decoded_info) CV_OVERRIDE;
|
||||
|
||||
private:
|
||||
QRCodeEncoder::CorrectionLevel level;
|
||||
int version;
|
||||
|
||||
struct Bitstream {
|
||||
int next(int bits) {
|
||||
CV_Assert(idx < data.size());
|
||||
|
||||
int val = 0;
|
||||
while (bits >= actualBits) {
|
||||
val |= data[idx++] << (bits - actualBits);
|
||||
bits -= actualBits;
|
||||
actualBits = 8;
|
||||
}
|
||||
if (bits) {
|
||||
val |= data[idx] >> (actualBits - bits);
|
||||
actualBits -= bits;
|
||||
data[idx] &= 255 >> (8 - actualBits);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
bool empty() {
|
||||
return idx >= data.size();
|
||||
}
|
||||
|
||||
std::vector<uint8_t> data;
|
||||
int actualBits = 8;
|
||||
size_t idx = 0;
|
||||
} bitstream;
|
||||
|
||||
bool run(const Mat& straight, String& decoded_info);
|
||||
bool decodeFormatInfo(const Mat& straight, int& mask);
|
||||
bool correctFormatInfo(uint16_t& format_info);
|
||||
void extractCodewords(Mat& source, std::vector<uint8_t>& codewords);
|
||||
bool errorCorrection(std::vector<uint8_t>& codewords);
|
||||
bool errorCorrectionBlock(std::vector<uint8_t>& codewords);
|
||||
void decodeSymbols(String& result);
|
||||
void decodeNumeric(String& result);
|
||||
void decodeAlpha(String& result);
|
||||
void decodeByte(String& result);
|
||||
void decodeECI(String& result);
|
||||
void decodeKanji(String& result);
|
||||
};
|
||||
|
||||
QRCodeDecoder::~QRCodeDecoder()
|
||||
{
|
||||
// nothing
|
||||
}
|
||||
|
||||
Ptr<QRCodeDecoder> QRCodeDecoder::create() {
|
||||
return makePtr<QRCodeDecoderImpl>();
|
||||
}
|
||||
|
||||
bool QRCodeDecoderImpl::decode(const Mat& _straight, String& decoded_info) {
|
||||
Mat straight = ~_straight; // Invert modules
|
||||
bool decoded = run(straight, decoded_info);
|
||||
if (!decoded) {
|
||||
cv::transpose(straight, straight);
|
||||
decoded = run(straight, decoded_info);
|
||||
}
|
||||
return decoded;
|
||||
}
|
||||
|
||||
// Unmask format info bits and apply error correction
|
||||
bool QRCodeDecoderImpl::correctFormatInfo(uint16_t& format_info) {
|
||||
static const uint16_t mask_pattern = 0b101010000010010;
|
||||
|
||||
cv::Hamming hd;
|
||||
for (int i = 0; i < 32; ++i) {
|
||||
// Compute Hamming distance
|
||||
int distance = hd(reinterpret_cast<const unsigned char*>(&formatInfoLUT[i]),
|
||||
reinterpret_cast<const unsigned char*>(&format_info), 2);
|
||||
// Up to 3 bit errors might be corrected.
|
||||
// So if distance is less or equal than 3 - we found a correct format info.
|
||||
if (distance <= 3) {
|
||||
format_info = formatInfoLUT[i] ^ mask_pattern;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool QRCodeDecoderImpl::decodeFormatInfo(const Mat& straight, int& mask) {
|
||||
// Read left-top format info
|
||||
uint16_t format_info = 0;
|
||||
for (int i = 0; i < 6; ++i)
|
||||
format_info |= (straight.at<uint8_t>(i, 8) & 1) << i;
|
||||
|
||||
format_info |= (straight.at<uint8_t>(7, 8) & 1) << 6;
|
||||
format_info |= (straight.at<uint8_t>(8, 8) & 1) << 7;
|
||||
format_info |= (straight.at<uint8_t>(8, 7) & 1) << 8;
|
||||
|
||||
for (int i = 9; i < 15; ++i)
|
||||
format_info |= (straight.at<uint8_t>(8, 14 - i) & 1) << i;
|
||||
|
||||
bool correct = correctFormatInfo(format_info);
|
||||
|
||||
// Format information 15bit sequence appears twice.
|
||||
// Try extract format info from different position.
|
||||
uint16_t format_info_dup = 0;
|
||||
for (int i = 0; i < 8; ++i)
|
||||
format_info_dup |= (straight.at<uint8_t>(8, straight.cols - 1 - i) & 1) << i;
|
||||
for (int i = 0; i < 7; ++i)
|
||||
format_info_dup |= (straight.at<uint8_t>(straight.rows - 7 + i, 8) & 1) << (i + 8);
|
||||
|
||||
if (correctFormatInfo(format_info_dup)) {
|
||||
// Both strings must be the same
|
||||
if (correct && format_info != format_info_dup)
|
||||
return false;
|
||||
format_info = format_info_dup;
|
||||
} else {
|
||||
if (!correct)
|
||||
return false;
|
||||
}
|
||||
|
||||
switch((format_info >> 13) & 0b11) {
|
||||
case 0: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_M; break;
|
||||
case 1: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_L; break;
|
||||
case 2: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_H; break;
|
||||
case 3: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_Q; break;
|
||||
};
|
||||
mask = (format_info >> 10) & 0b111;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QRCodeDecoderImpl::run(const Mat& straight, String& decoded_info) {
|
||||
CV_Assert(straight.rows == straight.cols);
|
||||
version = (straight.rows - 21) / 4 + 1;
|
||||
|
||||
decoded_info = "";
|
||||
mode = static_cast<QRCodeEncoder::EncodeMode>(0);
|
||||
eci = static_cast<QRCodeEncoder::ECIEncodings>(0);
|
||||
|
||||
// Decode format info
|
||||
int maskPattern;
|
||||
bool decoded = decodeFormatInfo(straight, maskPattern);
|
||||
if (!decoded) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Generate data mask
|
||||
Mat masked = straight.clone();
|
||||
maskData(straight, maskPattern, masked);
|
||||
|
||||
extractCodewords(masked, bitstream.data);
|
||||
if (!errorCorrection(bitstream.data)) {
|
||||
return false;
|
||||
}
|
||||
decodeSymbols(decoded_info);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QRCodeDecoderImpl::errorCorrection(std::vector<uint8_t>& codewords) {
|
||||
CV_CheckEQ((int)codewords.size(), version_info_database[version].total_codewords,
|
||||
"Number of codewords");
|
||||
|
||||
int numBlocks = version_info_database[version].ecc[level].num_blocks_in_G1 +
|
||||
version_info_database[version].ecc[level].num_blocks_in_G2;
|
||||
if (numBlocks == 1) {
|
||||
return errorCorrectionBlock(codewords);
|
||||
}
|
||||
|
||||
size_t numData = 0;
|
||||
std::vector<int> blockSizes;
|
||||
blockSizes.reserve(numBlocks);
|
||||
for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G1; ++i) {
|
||||
blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G1);
|
||||
numData += blockSizes.back();
|
||||
}
|
||||
for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G2; ++i) {
|
||||
blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G2);
|
||||
numData += blockSizes.back();
|
||||
}
|
||||
|
||||
// TODO: parallel_for
|
||||
std::vector<std::vector<uint8_t>> blocks(numBlocks);
|
||||
int minBlockSize = *std::min_element(blockSizes.begin(), blockSizes.end());
|
||||
size_t offset = 0;
|
||||
for (int i = 0; i < minBlockSize; ++i) {
|
||||
for (int j = 0; j < numBlocks; ++j) {
|
||||
blocks[j].push_back(codewords[offset++]);
|
||||
}
|
||||
}
|
||||
// Put remaining data codewords
|
||||
for (int j = 0; j < numBlocks; ++j) {
|
||||
CV_Assert(blockSizes[j] == minBlockSize || blockSizes[j] == minBlockSize + 1);
|
||||
if (blockSizes[j] > minBlockSize)
|
||||
blocks[j].push_back(codewords[offset++]);
|
||||
}
|
||||
// Copy error correction codewords
|
||||
int numEcc = version_info_database[version].ecc[level].ecc_codewords;
|
||||
for (int i = 0; i < numEcc; ++i) {
|
||||
for (int j = 0; j < numBlocks; ++j) {
|
||||
blocks[j].push_back(codewords[offset++]);
|
||||
}
|
||||
}
|
||||
|
||||
parallel_for_(Range(0, numBlocks), [&](const Range& r) {
|
||||
for (int i = r.start; i < r.end; ++i) {
|
||||
if (!errorCorrectionBlock(blocks[i])) {
|
||||
blocks[i].clear();
|
||||
return;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Collect blocks back after error correction. Trim error correction codewords.
|
||||
codewords.resize(numData);
|
||||
offset = 0;
|
||||
for (size_t i = 0; i < blocks.size(); ++i) {
|
||||
if (blocks[i].empty())
|
||||
return false;
|
||||
std::copy(blocks[i].begin(), blocks[i].end(), codewords.begin() + offset);
|
||||
offset += blocks[i].size();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QRCodeDecoderImpl::errorCorrectionBlock(std::vector<uint8_t>& codewords) {
|
||||
size_t numEcc = version_info_database[version].ecc[level].ecc_codewords;
|
||||
size_t numSyndromes = numEcc;
|
||||
|
||||
// According to the ISO there is a formula for a number of the syndromes.
|
||||
// However several tests don't pass the error correction step because of less number of syndromes:
|
||||
// 1M: qrcodes/detection/lots/image001.jpg from BoofCV (8 syndromes by formula, 10 needed)
|
||||
// 1L: Objdetect_QRCode_Multi.regression/13 (4 syndromes by formula, 6 needed)
|
||||
// 2L: qrcodes/detection/brightness/image011.jpg from BoofCV (8 syndromes by formula, 10 needed)
|
||||
if (numSyndromes % 2 == 1)
|
||||
numSyndromes -= 1;
|
||||
|
||||
// Compute syndromes
|
||||
bool hasError = false;
|
||||
std::vector<uint8_t> syndromes(numSyndromes, codewords[0]);
|
||||
for (size_t i = 0; i < syndromes.size(); ++i) {
|
||||
for (size_t j = 1; j < codewords.size(); ++j) {
|
||||
syndromes[i] = gfMul(syndromes[i], gfPow(2, static_cast<int>(i))) ^ codewords[j];
|
||||
}
|
||||
hasError |= syndromes[i] != 0;
|
||||
}
|
||||
if (!hasError) {
|
||||
// Trim error correction codewords
|
||||
codewords.resize(codewords.size() - numEcc);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Run Berlekamp–Massey algorithm to find error positions (coefficients of locator poly)
|
||||
size_t L = 0; // number of assumed errors
|
||||
size_t m = 1; // shift value (between C and B)
|
||||
uint8_t b = 1; // discrepancy from last L update
|
||||
|
||||
std::vector<uint8_t> C(numSyndromes, 0); // Error locator polynomial
|
||||
std::vector<uint8_t> B(numSyndromes, 0); // A copy of error locator from previos L update
|
||||
C[0] = B[0] = 1;
|
||||
for (size_t i = 0; i < numSyndromes; ++i) {
|
||||
CV_Assert(m + L - 1 < C.size()); // m >= 1 on any iteration
|
||||
uint8_t discrepancy = syndromes[i];
|
||||
for (size_t j = 1; j <= L; ++j) {
|
||||
discrepancy ^= gfMul(C[j], syndromes[i - j]);
|
||||
}
|
||||
|
||||
if (discrepancy == 0) {
|
||||
m += 1;
|
||||
} else {
|
||||
std::vector<uint8_t> C_copy = C;
|
||||
uint8_t inv_b = gfDiv(1, b);
|
||||
uint8_t tmp = gfMul(discrepancy, inv_b);
|
||||
|
||||
for (size_t j = 0; j < L; ++j) {
|
||||
C[m + j] ^= gfMul(tmp, B[j]);
|
||||
}
|
||||
|
||||
if (2 * L <= i) {
|
||||
L = i + 1 - L;
|
||||
B = C_copy;
|
||||
b = discrepancy;
|
||||
m = 1;
|
||||
} else {
|
||||
m += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// There is an error at i-th position if i is a root of locator poly
|
||||
std::vector<size_t> errLocs;
|
||||
errLocs.reserve(L);
|
||||
for (size_t i = 0; i < codewords.size(); ++i) {
|
||||
uint8_t val = 1;
|
||||
uint8_t pos = gfPow(2, static_cast<int>(i));
|
||||
for (size_t j = 1; j <= L; ++j) {
|
||||
val = gfMul(val, pos) ^ C[j];
|
||||
}
|
||||
if (val == 0) {
|
||||
errLocs.push_back(static_cast<int>(codewords.size() - 1 - i));
|
||||
}
|
||||
}
|
||||
|
||||
// Number of assumed errors does not match number of error locations
|
||||
if (errLocs.size() != L)
|
||||
return false;
|
||||
|
||||
// Forney algorithm for error correction using syndromes and known error locations
|
||||
std::vector<uint8_t> errEval;
|
||||
gfPolyMul(C, syndromes, errEval);
|
||||
|
||||
for (size_t i = 0; i < errLocs.size(); ++i) {
|
||||
uint8_t numenator = 0, denominator = 0;
|
||||
uint8_t X = gfPow(2, static_cast<int>(codewords.size() - 1 - errLocs[i]));
|
||||
uint8_t inv_X = gfDiv(1, X);
|
||||
|
||||
for (size_t j = 0; j < L; ++j) {
|
||||
numenator = gfMul(numenator, inv_X) ^ errEval[L - 1 - j];
|
||||
}
|
||||
|
||||
// Compute demoninator as a product of (1-X_i * X_k) for i != k
|
||||
// TODO: optimize, there is a dubplicated compute
|
||||
denominator = 1;
|
||||
for (size_t j = 0; j < errLocs.size(); ++j) {
|
||||
if (i == j)
|
||||
continue;
|
||||
uint8_t Xj = gfPow(2, static_cast<int>(codewords.size() - 1 - errLocs[j]));
|
||||
denominator = gfMul(denominator, 1 ^ gfMul(inv_X, Xj));
|
||||
}
|
||||
|
||||
uint8_t errValue = gfDiv(numenator, denominator);
|
||||
codewords[errLocs[i]] ^= errValue;
|
||||
}
|
||||
|
||||
// Trim error correction codewords
|
||||
codewords.resize(codewords.size() - numEcc);
|
||||
return true;
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::extractCodewords(Mat& source, std::vector<uint8_t>& codewords) {
|
||||
const VersionInfo& version_info = version_info_database[version];
|
||||
|
||||
// Mask alignment markers
|
||||
std::vector<int> alignCenters;
|
||||
alignCenters.reserve(MAX_ALIGNMENT);
|
||||
for (int i = 0; i < MAX_ALIGNMENT && version_info.alignment_pattern[i]; i++)
|
||||
alignCenters.push_back(version_info.alignment_pattern[i]);
|
||||
|
||||
for (size_t i = 0; i < alignCenters.size(); i++)
|
||||
{
|
||||
for (size_t j = 0; j < alignCenters.size(); j++)
|
||||
{
|
||||
if ((i == alignCenters.size() - 1 && j == 0) || (i == 0 && j == 0) ||
|
||||
(j == alignCenters.size() - 1 && i == 0))
|
||||
continue;
|
||||
int x = alignCenters[i];
|
||||
int y = alignCenters[j];
|
||||
Mat area = source({x - 2, x + 3}, {y - 2, y + 3});
|
||||
area.setTo(INVALID_REGION_VALUE);
|
||||
}
|
||||
}
|
||||
|
||||
// Mask detection markers
|
||||
source.rowRange(0, 9).colRange(source.cols - 8, source.cols).setTo(INVALID_REGION_VALUE);
|
||||
source.rowRange(0, 9).colRange(0, 9).setTo(INVALID_REGION_VALUE);
|
||||
source.colRange(0, 9).rowRange(source.rows - 8, source.rows).setTo(INVALID_REGION_VALUE);
|
||||
|
||||
// Mask Version Information blocks
|
||||
if (version >= 7) {
|
||||
source.rowRange(0, 6).colRange(source.cols - 12, source.cols - 9).setTo(INVALID_REGION_VALUE);
|
||||
source.colRange(0, 6).rowRange(source.rows - 12, source.rows - 9).setTo(INVALID_REGION_VALUE);
|
||||
}
|
||||
|
||||
// Mask timing pattern
|
||||
source.row(6) = INVALID_REGION_VALUE;
|
||||
|
||||
std::vector<uint8_t> bits;
|
||||
bits.reserve(source.total() - source.cols);
|
||||
bool moveUpwards = true;
|
||||
for (auto& data : {source.colRange(7, source.cols), source.colRange(0, 6)}) {
|
||||
for (int i = data.cols / 2 - 1; i >= 0; --i) {
|
||||
Mat col0 = data.col(i * 2);
|
||||
Mat col1 = data.col(i * 2 + 1);
|
||||
for (int j = 0; j < data.rows; ++j) {
|
||||
if (moveUpwards) {
|
||||
bits.push_back(col1.at<uint8_t>(data.rows - 1 - j));
|
||||
bits.push_back(col0.at<uint8_t>(data.rows - 1 - j));
|
||||
} else {
|
||||
bits.push_back(col1.at<uint8_t>(j));
|
||||
bits.push_back(col0.at<uint8_t>(j));
|
||||
}
|
||||
}
|
||||
moveUpwards = !moveUpwards;
|
||||
}
|
||||
}
|
||||
|
||||
// Combine bits to codewords
|
||||
size_t numCodewords = version_info.total_codewords;
|
||||
codewords.resize(numCodewords);
|
||||
|
||||
size_t offset = 0;
|
||||
for (size_t i = 0; i < numCodewords; ++i) {
|
||||
codewords[i] = 0;
|
||||
for (size_t j = 0; j < 8; ++j) {
|
||||
while (bits[offset] == INVALID_REGION_VALUE) {
|
||||
offset += 1;
|
||||
CV_Assert(offset < bits.size());
|
||||
}
|
||||
codewords[i] |= (bits[offset] & 1) << (7 - j);
|
||||
offset += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeSymbols(String& result) {
|
||||
CV_Assert(!bitstream.empty());
|
||||
|
||||
// Decode depends on the mode
|
||||
result = "";
|
||||
while (!bitstream.empty()) {
|
||||
// Determine mode
|
||||
auto currMode = static_cast<QRCodeEncoder::EncodeMode>(bitstream.next(4));
|
||||
if (this->mode == 0) {
|
||||
mode = currMode;
|
||||
}
|
||||
|
||||
if (currMode == 0 || bitstream.empty())
|
||||
return;
|
||||
if (currMode == QRCodeEncoder::EncodeMode::MODE_NUMERIC)
|
||||
decodeNumeric(result);
|
||||
else if (currMode == QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC)
|
||||
decodeAlpha(result);
|
||||
else if (currMode == QRCodeEncoder::EncodeMode::MODE_BYTE)
|
||||
decodeByte(result);
|
||||
else if (currMode == QRCodeEncoder::EncodeMode::MODE_ECI)
|
||||
decodeECI(result);
|
||||
else if (currMode == QRCodeEncoder::EncodeMode::MODE_KANJI)
|
||||
decodeKanji(result);
|
||||
else
|
||||
CV_Error(Error::StsNotImplemented, format("mode %d", currMode));
|
||||
}
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeNumeric(String& result) {
|
||||
int numDigits = bitstream.next(version <= 9 ? 10 : (version <= 26 ? 12 : 14));
|
||||
for (int i = 0; i < numDigits / 3; ++i) {
|
||||
int triple = bitstream.next(10);
|
||||
result += static_cast<char>('0' + triple / 100);
|
||||
result += static_cast<char>('0' + (triple / 10) % 10);
|
||||
result += static_cast<char>('0' + triple % 10);
|
||||
}
|
||||
int remainingDigits = numDigits % 3;
|
||||
if (remainingDigits) {
|
||||
int triple = bitstream.next(remainingDigits == 1 ? 4 : 7);
|
||||
if (remainingDigits == 2)
|
||||
result += '0' + (triple / 10) % 10;
|
||||
result += '0' + triple % 10;
|
||||
}
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeAlpha(String& result) {
|
||||
static const char map[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
|
||||
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
|
||||
'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*',
|
||||
'+', '-', '.', '/', ':'};
|
||||
|
||||
int num = bitstream.next(version <= 9 ? 9 : (version <= 26 ? 11 : 13));
|
||||
for (int i = 0; i < num / 2; ++i) {
|
||||
int tuple = bitstream.next(11);
|
||||
result += map[tuple / 45];
|
||||
result += map[tuple % 45];
|
||||
}
|
||||
if (num % 2) {
|
||||
int value = bitstream.next(6);
|
||||
result += map[value];
|
||||
}
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeByte(String& result) {
|
||||
int num = bitstream.next(version <= 9 ? 8 : 16);
|
||||
for (int i = 0; i < num; ++i) {
|
||||
result += static_cast<char>(bitstream.next(8));
|
||||
}
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeECI(String& result) {
|
||||
int eciAssignValue = bitstream.next(8);
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
if (eciAssignValue & 1 << (7 - i))
|
||||
eciAssignValue |= bitstream.next(8) << (i + 1) * 8;
|
||||
else
|
||||
break;
|
||||
}
|
||||
if (this->eci == 0) {
|
||||
this->eci = static_cast<QRCodeEncoder::ECIEncodings>(eciAssignValue);
|
||||
}
|
||||
decodeSymbols(result);
|
||||
|
||||
}
|
||||
|
||||
void QRCodeDecoderImpl::decodeKanji(String& result) {
|
||||
int num = bitstream.next(version <= 9 ? 8 : (version <= 26 ? 10 : 12));
|
||||
for (int i = 0; i < num; ++i) {
|
||||
int data = bitstream.next(13);
|
||||
int high_byte = data / 0xC0;
|
||||
int low_byte = data - high_byte * 0xC0;
|
||||
int symbol = (high_byte << 8) + low_byte;
|
||||
if (0 <= symbol && symbol <= 0x9FFC - 0x8140) {
|
||||
symbol += 0x8140;
|
||||
} else if (0xE040 - 0xC140 <= symbol && symbol <= 0xEBBF - 0xC140) {
|
||||
symbol += 0xC140;
|
||||
}
|
||||
result += (symbol >> 8) & 0xff;
|
||||
result += symbol & 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -857,4 +857,13 @@ static const uint8_t gf_log[256] = {
|
||||
0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
|
||||
0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
|
||||
};
|
||||
|
||||
// There are only 32 combinations of format info sequences.
|
||||
static const uint16_t formatInfoLUT[32] = {
|
||||
0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0,
|
||||
0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976,
|
||||
0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b,
|
||||
0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user