mirror of
https://github.com/seiichiro0185/sailotp.git
synced 2024-05-03 11:23:58 +00:00
101 lines
3.5 KiB
C++
101 lines
3.5 KiB
C++
/*
|
|
* ResultPoint.cpp
|
|
* zxing
|
|
*
|
|
* Created by Christian Brunschen on 13/05/2008.
|
|
* Copyright 2008 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/ResultPoint.h>
|
|
#include <math.h>
|
|
|
|
namespace zxing {
|
|
|
|
ResultPoint::ResultPoint() : posX_(0), posY_(0) {}
|
|
|
|
ResultPoint::ResultPoint(float x, float y) : posX_(x), posY_(y) {}
|
|
|
|
ResultPoint::~ResultPoint() {}
|
|
|
|
float ResultPoint::getX() const {
|
|
return posX_;
|
|
}
|
|
|
|
float ResultPoint::getY() const {
|
|
return posY_;
|
|
}
|
|
|
|
bool ResultPoint::equals(Ref<ResultPoint> other) {
|
|
return posX_ == other->getX() && posY_ == other->getY();
|
|
}
|
|
|
|
/**
|
|
* <p>Orders an array of three ResultPoints in an order [A,B,C] such that AB < AC and
|
|
* BC < AC and the angle between BC and BA is less than 180 degrees.
|
|
*/
|
|
void ResultPoint::orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns) {
|
|
// Find distances between pattern centers
|
|
float zeroOneDistance = distance(patterns[0]->getX(), patterns[1]->getX(),patterns[0]->getY(), patterns[1]->getY());
|
|
float oneTwoDistance = distance(patterns[1]->getX(), patterns[2]->getX(),patterns[1]->getY(), patterns[2]->getY());
|
|
float zeroTwoDistance = distance(patterns[0]->getX(), patterns[2]->getX(),patterns[0]->getY(), patterns[2]->getY());
|
|
|
|
Ref<ResultPoint> pointA, pointB, pointC;
|
|
// Assume one closest to other two is B; A and C will just be guesses at first
|
|
if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
|
|
pointB = patterns[0];
|
|
pointA = patterns[1];
|
|
pointC = patterns[2];
|
|
} else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
|
|
pointB = patterns[1];
|
|
pointA = patterns[0];
|
|
pointC = patterns[2];
|
|
} else {
|
|
pointB = patterns[2];
|
|
pointA = patterns[0];
|
|
pointC = patterns[1];
|
|
}
|
|
|
|
// Use cross product to figure out whether A and C are correct or flipped.
|
|
// This asks whether BC x BA has a positive z component, which is the arrangement
|
|
// we want for A, B, C. If it's negative, then we've got it flipped around and
|
|
// should swap A and C.
|
|
if (crossProductZ(pointA, pointB, pointC) < 0.0f) {
|
|
Ref<ResultPoint> temp = pointA;
|
|
pointA = pointC;
|
|
pointC = temp;
|
|
}
|
|
|
|
patterns[0] = pointA;
|
|
patterns[1] = pointB;
|
|
patterns[2] = pointC;
|
|
}
|
|
|
|
float ResultPoint::distance(Ref<ResultPoint> point1, Ref<ResultPoint> point2) {
|
|
return distance(point1->getX(), point1->getY(), point2->getX(), point2->getY());
|
|
}
|
|
|
|
float ResultPoint::distance(float x1, float x2, float y1, float y2) {
|
|
float xDiff = x1 - x2;
|
|
float yDiff = y1 - y2;
|
|
return (float) sqrt((double) (xDiff * xDiff + yDiff * yDiff));
|
|
}
|
|
|
|
float ResultPoint::crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB, Ref<ResultPoint> pointC) {
|
|
float bX = pointB->getX();
|
|
float bY = pointB->getY();
|
|
return ((pointC->getX() - bX) * (pointA->getY() - bY)) - ((pointC->getY() - bY) * (pointA->getX() - bX));
|
|
}
|
|
}
|