ResultPoint.cpp Example File

 // -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
 /*
  *  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 <zxing/common/detector/MathUtils.h>

 using zxing::common::detector::MathUtils;

 namespace zxing {

 ResultPoint::ResultPoint() : posX_(0), posY_(0) {}

 ResultPoint::ResultPoint(float x, float y) : posX_(x), posY_(y) {}

 ResultPoint::ResultPoint(int x, int y) : posX_(float(x)), posY_(float(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> pattern1, Ref<ResultPoint> pattern2) {
   return MathUtils::distance(pattern1->posX_,
                              pattern1->posY_,
                              pattern2->posX_,
                              pattern2->posY_);
 }

 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));
 }
 }