mirror of
https://github.com/seiichiro0185/sailotp.git
synced 2024-05-04 03:33:58 +00:00
542 lines
18 KiB
C++
542 lines
18 KiB
C++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
/*
|
|
* Detector.cpp
|
|
* zxing
|
|
*
|
|
* Created by Lukas Stabe on 08/02/2012.
|
|
* Copyright 2012 ZXing authors All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <zxing/aztec/detector/Detector.h>
|
|
#include <zxing/common/GridSampler.h>
|
|
#include <zxing/common/detector/WhiteRectangleDetector.h>
|
|
#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
|
|
#include <zxing/common/reedsolomon/ReedSolomonException.h>
|
|
#include <zxing/common/reedsolomon/GenericGF.h>
|
|
#include <iostream>
|
|
#include <cmath>
|
|
#include <zxing/NotFoundException.h>
|
|
|
|
using zxing::aztec::Detector;
|
|
using zxing::aztec::Point;
|
|
using zxing::aztec::AztecDetectorResult;
|
|
using zxing::Ref;
|
|
using zxing::ResultPoint;
|
|
using zxing::BitArray;
|
|
using zxing::BitMatrix;
|
|
|
|
Detector::Detector(Ref<BitMatrix> image):
|
|
image_(image),
|
|
nbLayers_(0),
|
|
nbDataBlocks_(0),
|
|
nbCenterLayers_(0) {
|
|
|
|
}
|
|
|
|
// using namespace std;
|
|
|
|
Ref<AztecDetectorResult> Detector::detect() {
|
|
Ref<Point> pCenter = getMatrixCenter();
|
|
|
|
std::vector<Ref<Point> > bullEyeCornerPoints = getBullEyeCornerPoints(pCenter);
|
|
|
|
extractParameters(bullEyeCornerPoints);
|
|
|
|
std::vector<Ref<ResultPoint> > corners = getMatrixCornerPoints(bullEyeCornerPoints);
|
|
|
|
Ref<BitMatrix> bits = sampleGrid(image_, corners[shift_%4], corners[(shift_+3)%4], corners[(shift_+2)%4], corners[(shift_+1)%4]);
|
|
|
|
// std::printf("------------\ndetected: compact:%s, nbDataBlocks:%d, nbLayers:%d\n------------\n",compact_?"YES":"NO", nbDataBlocks_, nbLayers_);
|
|
|
|
return Ref<AztecDetectorResult>(new AztecDetectorResult(bits, corners, compact_, nbDataBlocks_, nbLayers_));
|
|
}
|
|
|
|
void Detector::extractParameters(std::vector<Ref<Point> > bullEyeCornerPoints) {
|
|
// get the bits around the bull's eye
|
|
Ref<BitArray> resab = sampleLine(bullEyeCornerPoints[0], bullEyeCornerPoints[1], 2*nbCenterLayers_+1);
|
|
Ref<BitArray> resbc = sampleLine(bullEyeCornerPoints[1], bullEyeCornerPoints[2], 2*nbCenterLayers_+1);
|
|
Ref<BitArray> rescd = sampleLine(bullEyeCornerPoints[2], bullEyeCornerPoints[3], 2*nbCenterLayers_+1);
|
|
Ref<BitArray> resda = sampleLine(bullEyeCornerPoints[3], bullEyeCornerPoints[0], 2*nbCenterLayers_+1);
|
|
|
|
// determin the orientation of the matrix
|
|
if (resab->get(0) && resab->get(2 * nbCenterLayers_)) {
|
|
shift_ = 0;
|
|
} else if (resbc->get(0) && resbc->get(2 * nbCenterLayers_)) {
|
|
shift_ = 1;
|
|
} else if (rescd->get(0) && rescd->get(2 * nbCenterLayers_)) {
|
|
shift_ = 2;
|
|
} else if (resda->get(0) && resda->get(2 * nbCenterLayers_)) {
|
|
shift_ = 3;
|
|
} else {
|
|
// std::printf("could not detemine orientation\n");
|
|
throw ReaderException("could not determine orientation");
|
|
}
|
|
|
|
//d a
|
|
//
|
|
//c b
|
|
|
|
//flatten the bits in a single array
|
|
Ref<BitArray> parameterData(new BitArray(compact_?28:40));
|
|
Ref<BitArray> shiftedParameterData(new BitArray(compact_?28:40));
|
|
|
|
if (compact_) {
|
|
for (int i = 0; i < 7; i++) {
|
|
if (resab->get(2+i)) shiftedParameterData->set(i);
|
|
if (resbc->get(2+i)) shiftedParameterData->set(i+7);
|
|
if (rescd->get(2+i)) shiftedParameterData->set(i+14);
|
|
if (resda->get(2+i)) shiftedParameterData->set(i+21);
|
|
}
|
|
for (int i = 0; i < 28; i++) {
|
|
if (shiftedParameterData->get((i+shift_*7)%28)) parameterData->set(i);
|
|
}
|
|
|
|
} else {
|
|
for (int i = 0; i < 11; i++) {
|
|
if (i < 5) {
|
|
if (resab->get(2+i)) shiftedParameterData->set(i);
|
|
if (resbc->get(2+i)) shiftedParameterData->set(i+10);
|
|
if (rescd->get(2+i)) shiftedParameterData->set(i+20);
|
|
if (resda->get(2+i)) shiftedParameterData->set(i+30);
|
|
}
|
|
if (i > 5) {
|
|
if (resab->get(2+i)) shiftedParameterData->set(i-1);
|
|
if (resbc->get(2+i)) shiftedParameterData->set(i+10-1);
|
|
if (rescd->get(2+i)) shiftedParameterData->set(i+20-1);
|
|
if (resda->get(2+i)) shiftedParameterData->set(i+30-1);
|
|
}
|
|
}
|
|
for (int i = 0; i < 40; i++) {
|
|
if (shiftedParameterData->get((i+shift_*10)%40)) parameterData->set(i);
|
|
}
|
|
}
|
|
|
|
correctParameterData(parameterData, compact_);
|
|
|
|
getParameters(parameterData);
|
|
}
|
|
|
|
std::vector<Ref<ResultPoint> > Detector::getMatrixCornerPoints(std::vector<Ref<Point> > bullEyeCornerPoints) {
|
|
float ratio = (2 * nbLayers_ + (nbLayers_ > 4 ? 1 : 0) + (nbLayers_ - 4) / 8) / (2.0f * nbCenterLayers_);
|
|
|
|
int dx = bullEyeCornerPoints[0]->x - bullEyeCornerPoints[2]->x;
|
|
dx += dx > 0 ? 1 : -1;
|
|
int dy = bullEyeCornerPoints[0]->y - bullEyeCornerPoints[2]->y;
|
|
dy += dy > 0 ? 1 : -1;
|
|
|
|
int targetcx = ROUND(bullEyeCornerPoints[2]->x - ratio * dx);
|
|
int targetcy = ROUND(bullEyeCornerPoints[2]->y - ratio * dy);
|
|
|
|
int targetax = ROUND(bullEyeCornerPoints[0]->x + ratio * dx);
|
|
int targetay = ROUND(bullEyeCornerPoints[0]->y + ratio * dy);
|
|
|
|
dx = bullEyeCornerPoints[1]->x - bullEyeCornerPoints[3]->x;
|
|
dx += dx > 0 ? 1 : -1;
|
|
dy = bullEyeCornerPoints[1]->y - bullEyeCornerPoints[3]->y;
|
|
dy += dy > 0 ? 1 : -1;
|
|
|
|
int targetdx = ROUND(bullEyeCornerPoints[3]->x - ratio * dx);
|
|
int targetdy = ROUND(bullEyeCornerPoints[3]->y - ratio * dy);
|
|
int targetbx = ROUND(bullEyeCornerPoints[1]->x + ratio * dx);
|
|
int targetby = ROUND(bullEyeCornerPoints[1]->y + ratio * dy);
|
|
|
|
if (!isValid(targetax, targetay) ||
|
|
!isValid(targetbx, targetby) ||
|
|
!isValid(targetcx, targetcy) ||
|
|
!isValid(targetdx, targetdy)) {
|
|
throw ReaderException("matrix extends over image bounds");
|
|
}
|
|
std::vector<Ref<ResultPoint> > returnValue;
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetax, targetay)));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetbx, targetby)));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetcx, targetcy)));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetdx, targetdy)));
|
|
|
|
return returnValue;
|
|
|
|
}
|
|
|
|
void Detector::correctParameterData(Ref<zxing::BitArray> parameterData, bool compact) {
|
|
int numCodewords;
|
|
int numDataCodewords;
|
|
|
|
if (compact) {
|
|
numCodewords = 7;
|
|
numDataCodewords = 2;
|
|
} else {
|
|
numCodewords = 10;
|
|
numDataCodewords = 4;
|
|
}
|
|
|
|
int numECCodewords = numCodewords - numDataCodewords;
|
|
|
|
ArrayRef<int> parameterWords(new Array<int>(numCodewords));
|
|
|
|
int codewordSize = 4;
|
|
for (int i = 0; i < numCodewords; i++) {
|
|
int flag = 1;
|
|
for (int j = 1; j <= codewordSize; j++) {
|
|
if (parameterData->get(codewordSize*i + codewordSize - j)) {
|
|
parameterWords[i] += flag;
|
|
}
|
|
flag <<= 1;
|
|
}
|
|
}
|
|
|
|
try {
|
|
// std::printf("parameter data reed solomon\n");
|
|
ReedSolomonDecoder rsDecoder(GenericGF::AZTEC_PARAM);
|
|
rsDecoder.decode(parameterWords, numECCodewords);
|
|
} catch (ReedSolomonException& e) {
|
|
// std::printf("reed solomon decoding failed\n");
|
|
throw ReaderException("failed to decode parameter data");
|
|
}
|
|
|
|
parameterData->clear();
|
|
for (int i = 0; i < numDataCodewords; i++) {
|
|
int flag = 1;
|
|
for (int j = 1; j <= codewordSize; j++) {
|
|
if ((parameterWords[i] & flag) == flag) {
|
|
parameterData->set(i*codewordSize+codewordSize-j);
|
|
}
|
|
flag <<= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<Ref<Point> > Detector::getBullEyeCornerPoints(Ref<zxing::aztec::Point> pCenter) {
|
|
Ref<Point> pina = pCenter;
|
|
Ref<Point> pinb = pCenter;
|
|
Ref<Point> pinc = pCenter;
|
|
Ref<Point> pind = pCenter;
|
|
|
|
bool color = true;
|
|
|
|
for (nbCenterLayers_ = 1; nbCenterLayers_ < 9; nbCenterLayers_++) {
|
|
Ref<Point> pouta = getFirstDifferent(pina, color, 1, -1);
|
|
Ref<Point> poutb = getFirstDifferent(pinb, color, 1, 1);
|
|
Ref<Point> poutc = getFirstDifferent(pinc, color, -1, 1);
|
|
Ref<Point> poutd = getFirstDifferent(pind, color, -1, -1);
|
|
|
|
//d a
|
|
//
|
|
//c b
|
|
|
|
if (nbCenterLayers_ > 2) {
|
|
float q = distance(poutd, pouta) * nbCenterLayers_ / (distance(pind, pina) * (nbCenterLayers_ + 2));
|
|
if (q < 0.75 || q > 1.25 || !isWhiteOrBlackRectangle(pouta, poutb, poutc, poutd)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
pina = pouta;
|
|
pinb = poutb;
|
|
pinc = poutc;
|
|
pind = poutd;
|
|
|
|
color = !color;
|
|
}
|
|
|
|
if (nbCenterLayers_ != 5 && nbCenterLayers_ != 7) {
|
|
throw ReaderException("encountered wrong bullseye ring count");
|
|
}
|
|
|
|
compact_ = nbCenterLayers_ == 5;
|
|
|
|
|
|
|
|
float ratio = 0.75f*2 / (2*nbCenterLayers_-3);
|
|
|
|
int dx = pina->x - pind->x;
|
|
int dy = pina->y - pinc->y;
|
|
|
|
int targetcx = ROUND(pinc->x - ratio * dx);
|
|
int targetcy = ROUND(pinc->y - ratio * dy);
|
|
int targetax = ROUND(pina->x + ratio * dx);
|
|
int targetay = ROUND(pina->y + ratio * dy);
|
|
|
|
dx = pinb->x - pind->x;
|
|
dy = pinb->y - pind->y;
|
|
|
|
int targetdx = ROUND(pind->x - ratio * dx);
|
|
int targetdy = ROUND(pind->y - ratio * dy);
|
|
int targetbx = ROUND(pinb->x + ratio * dx);
|
|
int targetby = ROUND(pinb->y + ratio * dy);
|
|
|
|
if (!isValid(targetax, targetay) ||
|
|
!isValid(targetbx, targetby) ||
|
|
!isValid(targetcx, targetcy) ||
|
|
!isValid(targetdx, targetdy)) {
|
|
throw ReaderException("bullseye extends over image bounds");
|
|
}
|
|
|
|
std::vector<Ref<Point> > returnValue;
|
|
returnValue.push_back(Ref<Point>(new Point(targetax, targetay)));
|
|
returnValue.push_back(Ref<Point>(new Point(targetbx, targetby)));
|
|
returnValue.push_back(Ref<Point>(new Point(targetcx, targetcy)));
|
|
returnValue.push_back(Ref<Point>(new Point(targetdx, targetdy)));
|
|
|
|
return returnValue;
|
|
|
|
}
|
|
|
|
Ref<Point> Detector::getMatrixCenter() {
|
|
Ref<ResultPoint> pointA, pointB, pointC, pointD;
|
|
try {
|
|
|
|
std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_).detect();
|
|
pointA = cornerPoints[0];
|
|
pointB = cornerPoints[1];
|
|
pointC = cornerPoints[2];
|
|
pointD = cornerPoints[3];
|
|
|
|
} catch (NotFoundException& e) {
|
|
|
|
int cx = image_->getWidth() / 2;
|
|
int cy = image_->getHeight() / 2;
|
|
|
|
pointA = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy-15/2)), false, 1, -1)->toResultPoint();
|
|
pointB = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy+15/2)), false, 1, 1)->toResultPoint();
|
|
pointC = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy+15/2)), false, -1, -1)->toResultPoint();
|
|
pointD = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy-15/2)), false, -1, -1)->toResultPoint();
|
|
|
|
}
|
|
|
|
int cx = ROUND((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4);
|
|
int cy = ROUND((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4);
|
|
|
|
try {
|
|
|
|
std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_, 15, cx, cy).detect();
|
|
pointA = cornerPoints[0];
|
|
pointB = cornerPoints[1];
|
|
pointC = cornerPoints[2];
|
|
pointD = cornerPoints[3];
|
|
|
|
} catch (NotFoundException& e) {
|
|
|
|
pointA = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy-15/2)), false, 1, -1)->toResultPoint();
|
|
pointB = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy+15/2)), false, 1, 1)->toResultPoint();
|
|
pointC = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy+15/2)), false, -1, -1)->toResultPoint();
|
|
pointD = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy-15/2)), false, -1, -1)->toResultPoint();
|
|
|
|
}
|
|
|
|
cx = ROUND((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4);
|
|
cy = ROUND((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4);
|
|
|
|
return Ref<Point>(new Point(cx, cy));
|
|
|
|
}
|
|
|
|
Ref<BitMatrix> Detector::sampleGrid(Ref<zxing::BitMatrix> image,
|
|
Ref<zxing::ResultPoint> topLeft,
|
|
Ref<zxing::ResultPoint> bottomLeft,
|
|
Ref<zxing::ResultPoint> bottomRight,
|
|
Ref<zxing::ResultPoint> topRight) {
|
|
int dimension;
|
|
if (compact_) {
|
|
dimension = 4 * nbLayers_+11;
|
|
} else {
|
|
if (nbLayers_ <= 4) {
|
|
dimension = 4 * nbLayers_ + 15;
|
|
} else {
|
|
dimension = 4 * nbLayers_ + 2 * ((nbLayers_-4)/8 + 1) + 15;
|
|
}
|
|
}
|
|
|
|
GridSampler sampler = GridSampler::getInstance();
|
|
|
|
return sampler.sampleGrid(image,
|
|
dimension,
|
|
0.5f,
|
|
0.5f,
|
|
dimension - 0.5f,
|
|
0.5f,
|
|
dimension - 0.5f,
|
|
dimension - 0.5f,
|
|
0.5f,
|
|
dimension - 0.5f,
|
|
topLeft->getX(),
|
|
topLeft->getY(),
|
|
topRight->getX(),
|
|
topRight->getY(),
|
|
bottomRight->getX(),
|
|
bottomRight->getY(),
|
|
bottomLeft->getX(),
|
|
bottomLeft->getY());
|
|
}
|
|
|
|
void Detector::getParameters(Ref<zxing::BitArray> parameterData) {
|
|
nbLayers_ = 0;
|
|
nbDataBlocks_ = 0;
|
|
|
|
int nbBitsForNbLayers;
|
|
int nbBitsForNbDatablocks;
|
|
|
|
if (compact_) {
|
|
nbBitsForNbLayers = 2;
|
|
nbBitsForNbDatablocks = 6;
|
|
} else {
|
|
nbBitsForNbLayers = 5;
|
|
nbBitsForNbDatablocks = 11;
|
|
}
|
|
|
|
for (int i = 0; i < nbBitsForNbLayers; i++) {
|
|
nbLayers_ <<= 1;
|
|
if (parameterData->get(i)) {
|
|
nbLayers_ += 1;
|
|
}
|
|
}
|
|
|
|
for (int i = nbBitsForNbLayers; i < nbBitsForNbLayers + nbBitsForNbDatablocks; i++) {
|
|
nbDataBlocks_ <<= 1;
|
|
if (parameterData->get(i)) {
|
|
nbDataBlocks_ += 1;
|
|
}
|
|
}
|
|
|
|
nbLayers_ ++;
|
|
nbDataBlocks_ ++;
|
|
}
|
|
|
|
Ref<BitArray> Detector::sampleLine(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2, int size) {
|
|
Ref<BitArray> res(new BitArray(size));
|
|
|
|
float d = distance(p1, p2);
|
|
float moduleSize = d / (size-1);
|
|
float dx = moduleSize * (p2->x - p1->x)/d;
|
|
float dy = moduleSize * (p2->y - p1->y)/d;
|
|
|
|
float px = p1->x;
|
|
float py = p1->y;
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
if (image_->get(ROUND(px), ROUND(py))) res->set(i);
|
|
px += dx;
|
|
py += dy;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
bool Detector::isWhiteOrBlackRectangle(Ref<zxing::aztec::Point> p1,
|
|
Ref<zxing::aztec::Point> p2,
|
|
Ref<zxing::aztec::Point> p3,
|
|
Ref<zxing::aztec::Point> p4) {
|
|
int corr = 3;
|
|
|
|
p1 = new Point(p1->x - corr, p1->y + corr);
|
|
p2 = new Point(p2->x - corr, p2->y - corr);
|
|
p3 = new Point(p3->x + corr, p3->y - corr);
|
|
p4 = new Point(p4->x + corr, p4->y + corr);
|
|
|
|
int cInit = getColor(p4, p1);
|
|
|
|
if (cInit == 0) {
|
|
return false;
|
|
}
|
|
|
|
int c = getColor(p1, p2);
|
|
|
|
if (c != cInit) {
|
|
return false;
|
|
}
|
|
|
|
c = getColor(p2, p3);
|
|
|
|
if (c != cInit) {
|
|
return false;
|
|
}
|
|
|
|
c = getColor(p3, p4);
|
|
|
|
if (c != cInit) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int Detector::getColor(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2) {
|
|
float d = distance(p1, p2);
|
|
|
|
float dx = (p2->x - p1->x) / d;
|
|
float dy = (p2->y - p1->y) / d;
|
|
|
|
int error = 0;
|
|
|
|
float px = p1->x;
|
|
float py = p1->y;
|
|
|
|
bool colorModel = image_->get(p1->x, p1->y);
|
|
|
|
for (int i = 0; i < d; i++) {
|
|
px += dx;
|
|
py += dy;
|
|
if (image_->get(ROUND(px), ROUND(py)) != colorModel) {
|
|
error ++;
|
|
}
|
|
}
|
|
|
|
float errRatio = (float)error/d;
|
|
|
|
|
|
if (errRatio > 0.1 && errRatio < 0.9) {
|
|
return 0;
|
|
}
|
|
|
|
if (errRatio <= 0.1) {
|
|
return colorModel?1:-1;
|
|
} else {
|
|
return colorModel?-1:1;
|
|
}
|
|
}
|
|
|
|
Ref<Point> Detector::getFirstDifferent(Ref<zxing::aztec::Point> init, bool color, int dx, int dy) {
|
|
int x = init->x + dx;
|
|
int y = init->y + dy;
|
|
|
|
while (isValid(x, y) && image_->get(x, y) == color) {
|
|
x += dx;
|
|
y += dy;
|
|
}
|
|
|
|
x -= dx;
|
|
y -= dy;
|
|
|
|
while (isValid(x, y) && image_->get(x, y) == color) {
|
|
x += dx;
|
|
}
|
|
|
|
x -= dx;
|
|
|
|
while (isValid(x, y) && image_->get(x, y) == color) {
|
|
y += dy;
|
|
}
|
|
|
|
y -= dy;
|
|
|
|
return Ref<Point>(new Point(x, y));
|
|
}
|
|
|
|
bool Detector::isValid(int x, int y) {
|
|
return x >= 0 && x < (int)image_->getWidth() && y > 0 && y < (int)image_->getHeight();
|
|
}
|
|
|
|
float Detector::distance(Ref<zxing::aztec::Point> a, Ref<zxing::aztec::Point> b) {
|
|
return sqrtf((float)((a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y)));
|
|
}
|