TestMatrixVectorIO.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*/




/** 
    @test TestMatrixVectorIO.cpp
    @brief Test Matrix I/O precision issues.    
    @ingroup g_tests
    @author evers
*/

// one file used for I/O
#ifdef WIN32
#  define TMP "tmp.txt"
#else //WIN32
#  define TMP "/tmp/tmp.txt"
#endif //WIN32

#include <stdlib.h> // srand
#include <string>
#include <limits>

#include <Base/Math/Vector2.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Math/Vector4.hh>
#include <Base/Math/RGB.hh>
#include <Base/Math/RGBA.hh>

#include <Base/Math/Matrix2x2.hh>
#include <Base/Math/Matrix3x3.hh>
#include <Base/Math/Matrix3x4.hh>
#include <Base/Math/Matrix4x4.hh>



using namespace std;
using namespace BIAS;


// helper 
#define DISPVAL(_ARG) {string s(#_ARG); std::cout<<s<<" "<<endl<<_ARG<<endl;}


int g_result (0);  //< global result
int g_samples(20); //< gloabl nr. of random samples (default)


// random value [0..1]
double rand1(){
  return ((double)rand() / (double)RAND_MAX);
}


// typed random function inside values range
template <class T>
T myrand()
{
  T val = (T) ( rand1() * numeric_limits<T>::max());
  return val;
}


void checkRGBuc()
{
  cout<<FUNCNAME<<" ";
  // check disk I/O
  for (unsigned int i=0; (int)i<(int)g_samples; i++){
    RGBuc a(myrand<unsigned char>(), myrand<unsigned char>(), myrand<unsigned char>()), b;
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i<<"/"<<g_samples<<" with "<<endl
        <<"\ta="<<a<<endl
        <<"\tb="<<b );
      g_result=-1;
      return;
    }
  }
  cout<<" + OK"<<endl;
}


void checkRGBAuc()
{
  cout<<FUNCNAME<<" ";
  // check disk I/O
  for (unsigned int i=0; (int)i<(int)g_samples; i++){
    RGBAuc a(myrand<unsigned char>(), myrand<unsigned char>(), myrand<unsigned char>(), myrand<unsigned char>()), b;
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i<<"/"<<g_samples<<" with "<<endl
        <<"\ta="<<a<<endl
        <<"\tb="<<b );
      g_result=-1;
      return;
    }
  }
  cout<<" + OK"<<endl;
}


void checkRGBAf()
{
  cout<<FUNCNAME<<" ";
  // check disk I/O
  for (unsigned int i=0; (int)i<(int)g_samples; i++){
    RGBAf a(myrand<float>(), myrand<float>(), myrand<float>(), myrand<float>()), b;
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i<<"/"<<g_samples<<" with "<<endl
        <<"\ta="<<a<<endl
        <<"\tb="<<b );
      g_result=-1;
      return;
    }
  }
  cout<<" + OK"<<endl;
}


void checkRGBf()
{
  cout<<FUNCNAME<<" ";
  // check disk I/O
  for (unsigned int i=0; (int)i<(int)g_samples; i++){
    RGBf a(myrand<float>(), myrand<float>(), myrand<float>()), b;
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i<<"/"<<g_samples<<" with "<<endl
        <<"\ta="<<a<<endl
        <<"\tb="<<b );
      g_result=-1;
      return;
    }
  }
  cout<<" + OK"<<endl;
}


template <class TYPE, class T>
void display(const unsigned int samples=1)
{

#ifdef WIN32
  cout
    <<FUNCNAME<<" "
    <<"TYPE="<<typeid(TYPE).name()<<" "
    <<"T="<<typeid(T).name()<<" "<<endl;
#else
  cout<<FUNCNAME<<" "<<endl;
#endif

  TYPE a;
  a.SetZero();
  for (unsigned int jj=0; (int)jj<(int)a.GetNumElements(); jj++){
    if (jj==0)
      a.GetData()[jj]=numeric_limits<T>::min();
    else if (jj==1)
      a.GetData()[jj]=numeric_limits<T>::max();
    else if (jj==2)
      a.GetData()[jj]=(T)0;
    else
      a.GetData()[jj]=myrand<T>();
  }
  cout<<a<<endl;
}


// For fixed size matrix, vector, i.e. Vector3<> Matrix3x3<> etc.
template <class TYPE, class T>
void check(const unsigned int samples=1)
{

#ifdef WIN32
  cout
    <<FUNCNAME<<" "
    <<"TYPE="<<typeid(TYPE).name()<<" "
    <<"T="<<typeid(T).name()<<" ";
#else
  cout<<FUNCNAME<<" ";
#endif

  // check disk I/O
  for (unsigned int i=0; i<samples; i++)
  {
    TYPE a, b;
    for (unsigned int jj=0; (int)jj<(int)a.GetNumElements(); jj++)
      a.GetData()[jj]=myrand<T>();

    b.SetZero();
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i+1<<"/"<<samples<<" with "<<endl
        <<"a="<<a<<endl
        <<"b="<<b<<endl
        <<"delta:"<<a-b<<endl
        );
      cout<<a<<endl; // DBG
      g_result=-1;
      return;
    }
  }
  cout<<"+ OK"<<endl;
  // example display to check formatting
  display<TYPE, T>();
}


// For arbitrary sized Matrix<>
// copy of the above with additional 2D dimension
template <class TYPE, class T>
void checkWithDim2(const unsigned int dim, const unsigned int samples)
{

#ifdef WIN32
  cout
    <<FUNCNAME<<" "
    <<"TYPE="<<typeid(TYPE).name()<<" "
    <<"T="<<typeid(T).name()<<" "
    <<"dim="<<dim<<" ";
#else
  CALLINFO;
#endif

  // check disk I/O
  for (unsigned int i=0; i<samples; i++)
  {
    TYPE a, b;
    a.newsize(dim, dim+1);
    for (unsigned int jj=0; (int)jj<(int)a.GetNumElements(); jj++)
      a.GetData()[jj]=myrand<T>();
    b.clear();
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i+1<<"/"<<samples<<" with "<<endl
        <<"a="<<a<<endl
        <<"b="<<b<<endl
        <<"delta:"<<a-b<<endl
        );
      g_result=-1;
      return;
    }
  }
  cout<<"+ OK"<<endl;
}



// For arbitrary sized Matrix<>
// copy of teh above with additional 1D dimension
template <class TYPE, class T>
void checkWithDim1(const unsigned int dim, const unsigned int samples)
{

#ifdef WIN32
  cout
    <<FUNCNAME<<" "
    <<"TYPE="<<typeid(TYPE).name()<<" "
    <<"T="<<typeid(T).name()<<" "
    <<"dim="<<dim<<" ";
#else
  CALLINFO;
#endif

  // check disk I/O
  for (unsigned int i=0; i<samples; i++)
  {
    TYPE a, b;
    a.newsize(dim);
    for (unsigned int jj=0; (int)jj<(int)a.GetNumElements(); jj++)
      a.GetData()[jj]=myrand<T>();
    b.clear();
    a.Save(TMP);
    b.Load(TMP);
    if (!(a==b)){
      BIASERR("failed: Save/Load to "<<TMP<<" on sample "<<i+1<<"/"<<samples<<" with "<<endl
        <<"a="<<a<<endl
        <<"b="<<b<<endl
        <<"delta:"<<a-b<<endl
        );
      g_result=-1;
      return;
    }
  }
  cout<<"+ OK"<<endl;
}



// checks all value types of one templated class
#define CHECK_TYPE( _TPLCLASS ) \
  check< _TPLCLASS< unsigned char >, unsigned char >(); \
  check< _TPLCLASS< char          >, char >(); \
  check< _TPLCLASS< int           >, int >(); \
  check< _TPLCLASS< unsigned short>, unsigned short >(); \
  check< _TPLCLASS< int           >, int >(); \
  check< _TPLCLASS< float         >, float >(); \
  check< _TPLCLASS< double        >, double >(); 


// entry
int main(int argc, char** argv)
{
  //srand(1); // pseudo random numbers only - same numbers on each run for debugging

  // ctest needs this for >1024 chars output: 
  cout<<"CTEST_FULL_OUTPUT"<<endl;

  if (argc>0)
    cout<<"started "<<argv[0]<<endl;

  if (argc>1)
    g_samples=atoi(argv[1]);
  cout<<"using "<<g_samples<<" random samples for each instance."<<endl;

  // check fixed size types
  // macro based check for all storage types (float, int, ...)
  CHECK_TYPE(Vector2);
  CHECK_TYPE(Vector3); // contains RGB
  CHECK_TYPE(Vector4); // contains RGBA
  CHECK_TYPE(Matrix2x2);
  CHECK_TYPE(Matrix3x3);
  CHECK_TYPE(Matrix3x4);
  CHECK_TYPE(Matrix4x4);

  // check variable size 2D types
  checkWithDim2< BIAS::Matrix<double>,        double>        (7,   g_samples); // e.g. 7x(7+1)=56 elements
  checkWithDim2< BIAS::Matrix<float>,         float>         (7,   g_samples);
  checkWithDim2< BIAS::Matrix<int>,           int>           (7,   g_samples);
  checkWithDim2< BIAS::Matrix<unsigned char>, unsigned char> (7,   g_samples);
  checkWithDim2< BIAS::Matrix<char         >, char>          (7,   g_samples);
  checkWithDim2< BIAS::Matrix<unsigned short>,unsigned short>(7,   g_samples);

  // check variable size 1D types
  checkWithDim1< BIAS::Vector<double>,        double>        (42,   g_samples); //i.e. 42 elements
  checkWithDim1< BIAS::Vector<float>,         float>         (42,   g_samples);
  checkWithDim1< BIAS::Vector<int>,           int>           (42,   g_samples);
  checkWithDim1< BIAS::Vector<unsigned char>, unsigned char> (42,   g_samples);
  checkWithDim1< BIAS::Vector<char         >, char>          (42,   g_samples);
  checkWithDim1< BIAS::Vector<unsigned short>,unsigned short>(42,   g_samples);


  // just to be 150% sure, check the typedefed names again
  checkRGBuc ();
  checkRGBAuc();
  checkRGBf  ();
  checkRGBAf (); 

  // show the values to check formatting / layout
  DISPVAL(RGBuc (0, 255, 3));
  DISPVAL(RGBAuc(0, 255, 3, 4));
  DISPVAL(RGBf (1.f/3.f, -2.2f, 3.3f));
  DISPVAL(RGBAf(1.f/3.f, -2.2f, 3.3f, 4.4f));

  // done, final result
  if (g_result!=0){
    cout<<"test failed with result="<<g_result<<endl;
    return g_result;
  } else {
    cout<<"OK - test succeeded."<<endl;
    return 0; // success
  }
}