cpp/core/src/zxing/common/PerspectiveTransform.cpp

   1 /*
   2  *  PerspectiveTransform.cpp
   3  *  zxing
   4  *
   5  *  Created by Christian Brunschen on 12/05/2008.
   6  *  Copyright 2008 Google UK. All rights reserved.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <zxing/common/PerspectiveTransform.h>
  22
  23 namespace zxing {
  24 using namespace std;
  25
  26 PerspectiveTransform::PerspectiveTransform(float a11, float a21, float a31, float a12, float a22, float a32, float a13,
  27     float a23, float a33) {
  28   this->a11 = a11;
  29   this->a12 = a12;
  30   this->a13 = a13;
  31   this->a21 = a21;
  32   this->a22 = a22;
  33   this->a23 = a23;
  34   this->a31 = a31;
  35   this->a32 = a32;
  36   this->a33 = a33;
  37 }
  38
  39 Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1,
  40     float x2, float y2, float x3, float y3, float x0p, float y0p, float x1p, float y1p, float x2p, float y2p,
  41     float x3p, float y3p) {
  42   Ref<PerspectiveTransform> qToS = PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
  43   Ref<PerspectiveTransform> sToQ =
  44     PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
  45   return sToQ->times(qToS);
  46 }
  47
  48 Ref<PerspectiveTransform> PerspectiveTransform::squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2,
  49     float y2, float x3, float y3) {
  50   float dy2 = y3 - y2;
  51   float dy3 = y0 - y1 + y2 - y3;
  52   if (dy2 == 0.0f && dy3 == 0.0f) {
  53     Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f,
  54                                      0.0f, 1.0f));
  55     return result;
  56   } else {
  57     float dx1 = x1 - x2;
  58     float dx2 = x3 - x2;
  59     float dx3 = x0 - x1 + x2 - x3;
  60     float dy1 = y1 - y2;
  61     float denominator = dx1 * dy2 - dx2 * dy1;
  62     float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
  63     float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
  64     Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0
  65                                      + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f));
  66     return result;
  67   }
  68 }
  69
  70 Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2,
  71     float y2, float x3, float y3) {
  72   // Here, the adjoint serves as the inverse:
  73   return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)->buildAdjoint();
  74 }
  75
  76 Ref<PerspectiveTransform> PerspectiveTransform::buildAdjoint() {
  77   // Adjoint is the transpose of the cofactor matrix:
  78   Ref<PerspectiveTransform> result(new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32
  79                                    - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22,
  80                                    a13 * a21 - a11 * a23, a11 * a22 - a12 * a21));
  81   return result;
  82 }
  83
  84 Ref<PerspectiveTransform> PerspectiveTransform::times(Ref<PerspectiveTransform> other) {
  85   Ref<PerspectiveTransform> result(new PerspectiveTransform(a11 * other->a11 + a21 * other->a12 + a31 * other->a13,
  86                                    a11 * other->a21 + a21 * other->a22 + a31 * other->a23, a11 * other->a31 + a21 * other->a32 + a31
  87                                    * other->a33, a12 * other->a11 + a22 * other->a12 + a32 * other->a13, a12 * other->a21 + a22
  88                                    * other->a22 + a32 * other->a23, a12 * other->a31 + a22 * other->a32 + a32 * other->a33, a13
  89                                    * other->a11 + a23 * other->a12 + a33 * other->a13, a13 * other->a21 + a23 * other->a22 + a33
  90                                    * other->a23, a13 * other->a31 + a23 * other->a32 + a33 * other->a33));
  91   return result;
  92 }
  93
  94 void PerspectiveTransform::transformPoints(valarray<float> &points) {
  95   int max = points.size();
  96   float a11 = this->a11;
  97   float a12 = this->a12;
  98   float a13 = this->a13;
  99   float a21 = this->a21;
 100   float a22 = this->a22;
 101   float a23 = this->a23;
 102   float a31 = this->a31;
 103   float a32 = this->a32;
 104   float a33 = this->a33;
 105   for (int i = 0; i < max; i += 2) {
 106     float x = points[i];
 107     float y = points[i + 1];
 108     float denominator = a13 * x + a23 * y + a33;
 109     points[i] = (a11 * x + a21 * y + a31) / denominator;
 110     points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
 111   }
 112 }
 113
 114 ostream& operator<<(ostream& out, PerspectiveTransform &pt) {
 115   out << pt.a11 << ", " << pt.a12 << ", " << pt.a13 << ", \n";
 116   out << pt.a21 << ", " << pt.a22 << ", " << pt.a23 << ", \n";
 117   out << pt.a31 << ", " << pt.a32 << ", " << pt.a33 << "\n";
 118   return out;
 119 }
 120
 121 }