mirror of
https://github.com/seiichiro0185/sailotp.git
synced 2024-05-19 08:50:54 +00:00
549 lines
19 KiB
C++
549 lines
19 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 <zxing/common/detector/MathUtils.h>
|
|
#include <zxing/NotFoundException.h>
|
|
|
|
using std::vector;
|
|
using zxing::aztec::Detector;
|
|
using zxing::aztec::Point;
|
|
using zxing::aztec::AztecDetectorResult;
|
|
using zxing::Ref;
|
|
using zxing::ArrayRef;
|
|
using zxing::ResultPoint;
|
|
using zxing::BitArray;
|
|
using zxing::BitMatrix;
|
|
using zxing::common::detector::MathUtils;
|
|
|
|
Detector::Detector(Ref<BitMatrix> image):
|
|
image_(image),
|
|
nbLayers_(0),
|
|
nbDataBlocks_(0),
|
|
nbCenterLayers_(0) {
|
|
|
|
}
|
|
|
|
Ref<AztecDetectorResult> Detector::detect() {
|
|
Ref<Point> pCenter = getMatrixCenter();
|
|
|
|
std::vector<Ref<Point> > bullEyeCornerPoints = getBullEyeCornerPoints(pCenter);
|
|
|
|
extractParameters(bullEyeCornerPoints);
|
|
|
|
ArrayRef< 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) {
|
|
int twoCenterLayers = 2 * nbCenterLayers_;
|
|
// get the bits around the bull's eye
|
|
Ref<BitArray> resab = sampleLine(bullEyeCornerPoints[0], bullEyeCornerPoints[1], twoCenterLayers+1);
|
|
Ref<BitArray> resbc = sampleLine(bullEyeCornerPoints[1], bullEyeCornerPoints[2], twoCenterLayers+1);
|
|
Ref<BitArray> rescd = sampleLine(bullEyeCornerPoints[2], bullEyeCornerPoints[3], twoCenterLayers+1);
|
|
Ref<BitArray> resda = sampleLine(bullEyeCornerPoints[3], bullEyeCornerPoints[0], twoCenterLayers+1);
|
|
|
|
// determin the orientation of the matrix
|
|
if (resab->get(0) && resab->get(twoCenterLayers)) {
|
|
shift_ = 0;
|
|
} else if (resbc->get(0) && resbc->get(twoCenterLayers)) {
|
|
shift_ = 1;
|
|
} else if (rescd->get(0) && rescd->get(twoCenterLayers)) {
|
|
shift_ = 2;
|
|
} else if (resda->get(0) && resda->get(twoCenterLayers)) {
|
|
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+9);
|
|
if (rescd->get(2+i)) shiftedParameterData->set(i+19);
|
|
if (resda->get(2+i)) shiftedParameterData->set(i+29);
|
|
}
|
|
}
|
|
for (int i = 0; i < 40; i++) {
|
|
if (shiftedParameterData->get((i+shift_*10)%40)) parameterData->set(i);
|
|
}
|
|
}
|
|
|
|
correctParameterData(parameterData, compact_);
|
|
|
|
getParameters(parameterData);
|
|
}
|
|
|
|
ArrayRef< 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]->getX() - bullEyeCornerPoints[2]->getX();
|
|
dx += dx > 0 ? 1 : -1;
|
|
int dy = bullEyeCornerPoints[0]->getY() - bullEyeCornerPoints[2]->getY();
|
|
dy += dy > 0 ? 1 : -1;
|
|
|
|
int targetcx = MathUtils::round(bullEyeCornerPoints[2]->getX() - ratio * dx);
|
|
int targetcy = MathUtils::round(bullEyeCornerPoints[2]->getY() - ratio * dy);
|
|
|
|
int targetax = MathUtils::round(bullEyeCornerPoints[0]->getX() + ratio * dx);
|
|
int targetay = MathUtils::round(bullEyeCornerPoints[0]->getY() + ratio * dy);
|
|
|
|
dx = bullEyeCornerPoints[1]->getX() - bullEyeCornerPoints[3]->getX();
|
|
dx += dx > 0 ? 1 : -1;
|
|
dy = bullEyeCornerPoints[1]->getY() - bullEyeCornerPoints[3]->getY();
|
|
dy += dy > 0 ? 1 : -1;
|
|
|
|
int targetdx = MathUtils::round(bullEyeCornerPoints[3]->getX() - ratio * dx);
|
|
int targetdy = MathUtils::round(bullEyeCornerPoints[3]->getY() - ratio * dy);
|
|
int targetbx = MathUtils::round(bullEyeCornerPoints[1]->getX() + ratio * dx);
|
|
int targetby = MathUtils::round(bullEyeCornerPoints[1]->getY() + ratio * dy);
|
|
|
|
if (!isValid(targetax, targetay) ||
|
|
!isValid(targetbx, targetby) ||
|
|
|
|
!isValid(targetcx, targetcy) ||
|
|
!isValid(targetdx, targetdy)) {
|
|
throw ReaderException("matrix extends over image bounds");
|
|
}
|
|
Array< Ref<ResultPoint> >* array = new Array< Ref<ResultPoint> >();
|
|
vector< Ref<ResultPoint> >& returnValue (array->values());
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetax), float(targetay))));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetbx), float(targetby))));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetcx), float(targetcy))));
|
|
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetdx), float(targetdy))));
|
|
return ArrayRef< Ref<ResultPoint> >(array);
|
|
}
|
|
|
|
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 const& ignored) {
|
|
(void)ignored;
|
|
// 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->getX() - pind->getX();
|
|
int dy = pina->getY() - pinc->getY();
|
|
|
|
int targetcx = MathUtils::round(pinc->getX() - ratio * dx);
|
|
int targetcy = MathUtils::round(pinc->getY() - ratio * dy);
|
|
int targetax = MathUtils::round(pina->getX() + ratio * dx);
|
|
int targetay = MathUtils::round(pina->getY() + ratio * dy);
|
|
|
|
dx = pinb->getX() - pind->getX();
|
|
dy = pinb->getY() - pind->getY();
|
|
|
|
int targetdx = MathUtils::round(pind->getX() - ratio * dx);
|
|
int targetdy = MathUtils::round(pind->getY() - ratio * dy);
|
|
int targetbx = MathUtils::round(pinb->getX() + ratio * dx);
|
|
int targetby = MathUtils::round(pinb->getY() + 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 const& e) {
|
|
(void)e;
|
|
|
|
int cx = image_->getWidth() / 2;
|
|
int cy = image_->getHeight() / 2;
|
|
|
|
pointA = getFirstDifferent(Ref<Point>(new Point(cx+7, cy-7)), false, 1, -1)->toResultPoint();
|
|
pointB = getFirstDifferent(Ref<Point>(new Point(cx+7, cy+7)), false, 1, 1)->toResultPoint();
|
|
pointC = getFirstDifferent(Ref<Point>(new Point(cx-7, cy+7)), false, -1, -1)->toResultPoint();
|
|
pointD = getFirstDifferent(Ref<Point>(new Point(cx-7, cy-7)), false, -1, -1)->toResultPoint();
|
|
|
|
}
|
|
|
|
int cx = MathUtils::round((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4.0f);
|
|
int cy = MathUtils::round((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4.0f);
|
|
|
|
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 const& e) {
|
|
(void)e;
|
|
|
|
pointA = getFirstDifferent(Ref<Point>(new Point(cx+7, cy-7)), false, 1, -1)->toResultPoint();
|
|
pointB = getFirstDifferent(Ref<Point>(new Point(cx+7, cy+7)), false, 1, 1)->toResultPoint();
|
|
pointC = getFirstDifferent(Ref<Point>(new Point(cx-7, cy+7)), false, -1, 1)->toResultPoint();
|
|
pointD = getFirstDifferent(Ref<Point>(new Point(cx-7, cy-7)), false, -1, -1)->toResultPoint();
|
|
|
|
}
|
|
|
|
cx = MathUtils::round((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4.0f);
|
|
cy = MathUtils::round((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4.0f);
|
|
|
|
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_++;
|
|
}
|
|
}
|
|
|
|
for (int i = nbBitsForNbLayers; i < nbBitsForNbLayers + nbBitsForNbDatablocks; i++) {
|
|
nbDataBlocks_ <<= 1;
|
|
if (parameterData->get(i)) {
|
|
nbDataBlocks_++;
|
|
}
|
|
}
|
|
|
|
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 * float(p2->getX() - p1->getX())/d;
|
|
float dy = moduleSize * float(p2->getY() - p1->getY())/d;
|
|
|
|
float px = float(p1->getX());
|
|
float py = float(p1->getY());
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
if (image_->get(MathUtils::round(px), MathUtils::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->getX() - corr, p1->getY() + corr);
|
|
p2 = new Point(p2->getX() - corr, p2->getY() - corr);
|
|
p3 = new Point(p3->getX() + corr, p3->getY() - corr);
|
|
p4 = new Point(p4->getX() + corr, p4->getY() + 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->getX() - p1->getX()) / d;
|
|
float dy = (p2->getY() - p1->getY()) / d;
|
|
|
|
int error = 0;
|
|
|
|
float px = float(p1->getX());
|
|
float py = float(p1->getY());
|
|
|
|
bool colorModel = image_->get(p1->getX(), p1->getY());
|
|
|
|
for (int i = 0; i < d; i++) {
|
|
px += dx;
|
|
py += dy;
|
|
if (image_->get(MathUtils::round(px), MathUtils::round(py)) != colorModel) {
|
|
error ++;
|
|
}
|
|
}
|
|
|
|
float errRatio = (float)error/d;
|
|
|
|
|
|
if (errRatio > 0.1f && errRatio < 0.9f) {
|
|
return 0;
|
|
}
|
|
|
|
return (errRatio <= 0.1) == colorModel ? 1 : -1;
|
|
}
|
|
|
|
Ref<Point> Detector::getFirstDifferent(Ref<zxing::aztec::Point> init, bool color, int dx, int dy) {
|
|
int x = init->getX() + dx;
|
|
int y = init->getY() + 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->getX() - b->getX()) * (a->getX() - b->getX()) + (a->getY() - b->getY()) * (a->getY() - b->getY())));
|
|
}
|