TestProjectionParametersOrthographic.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).
   
   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/**
   @file TestProjectionParametersOrthographic.cpp
   @brief Unit test for basic functionality of projection parameters orthographic.
   @relates ProjectionParametersOrthographic
   @ingroup g_tests
   @author MIP
*/


#include <Base/Common/CompareFloatingPoint.hh>

#include <Geometry/ProjectionParametersOrthographic.hh>
#include <Base/Math/Random.hh>
#include <string>
#include <vector>


using namespace BIAS;
using namespace std;
typedef ProjectionParametersOrthographic PPO;

#define EPSILON       1e-8


int main(int argc, char *argv[]){
  const unsigned int width = 800;
  const unsigned int height = 600;
  Vector3<double> rayDir(0, 0, 1);
  double dX = 1;
  double dY = 1;
  PPO ppo(rayDir, width, height, dX, dY);
  ppo.SetPrincipal(561.5692167, 348.5405689);
  
  Quaternion<double> Q(0,0,0,1);
  ppo.SetQ(Q);
  Vector3<double> C(0,0,0);
  ppo.SetC(C);
  
  Random rand;
  int percent = -1;

  int countError = 0;
  int countAll = 0;
  double sumError = 0.0;
  double sumSqError = 0.0;
  
  unsigned int numCams = 100;   //1000
  unsigned int numPoints = 100; //1000
  
  HomgPoint2D p2d;
  HomgPoint2D p2d_p;
  HomgPoint3D p3d;
  double maxError = 0.0;
  double dist = 0;
  double error = 0;

  for(unsigned int cams=0; cams < numCams; cams++){
    ppo.SetPrincipal(rand.GetUniformDistributed(100, 700),
                     rand.GetUniformDistributed(100, 500));
    for(unsigned int points=0; points < numPoints; points++){
      if(points == 0){
        // use origin as first 2d point
        p2d[0] = p2d[1] = 0.0;
        p2d[2] = 1.0;
        dist = 5000.0;
      }else{
        // generate random 2d point and depth
        p2d[0] = rand.GetUniformDistributed(10, width-11); 
        p2d[1] = rand.GetUniformDistributed(10, height-11);
        p2d[2] = 1.0;
        dist = rand.GetUniformDistributed(100.0, 5000.0);
      }

      p3d = ppo.UnProjectToPoint(p2d, dist, true);
      p2d_p = ppo.Project(p3d, true);
      error = (p2d_p.GetEuclidean()-p2d.GetEuclidean()).NormL2();
      cout<<"point: "<<p2d<<" proj_point: "<<p2d_p<<" error: "<<error<<endl;
      if(Greater(error, EPSILON)){
        countError++;
      }
      if(maxError < error){
        maxError = error;
      }     
      sumError += error;
      sumSqError += error*error;
      countAll++;
    }

    //  show progress
    int pr = int(100.0*double(cams)/numCams);
    if(percent < pr){
      while(percent < pr) {
        cout<<".";
        percent++;
      }
      cout<<" "<<percent<<"% ";
    }
  }

  double meanError = sumError / (double)countAll;
  double stdError = sqrt(sumSqError / (double)countAll - meanError*meanError);

  cout<<"\n\n----------------------------------------------------------\n"
      <<" count of errors > "<<EPSILON<<" : "<<countError
      <<" ("<<100.0*(double)countError/(double)countAll<<"%)\n"
      <<" average error : "<<meanError<<" +- "<<stdError<<endl
      <<" max. error : "<<maxError<<endl
      <<"----------------------------------------------------------\n\n";
  
  return 0;
}