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

#include "SymmetricMatrix3x3.hh"

#include <Base/Common/CompareFloatingPoint.hh>
#include <Base/Math/Matrix3x3.hh>
#include <Base/Math/Matrix.hh>
#include <Base/Math/Utils.hh>
#include <Base/Debug/Exception.hh>

#include <iostream>
#include <climits>

using namespace std;

namespace BIAS {

  /// @author woelk 11/2007 (c) www.vision-n.de
  template <class T>
  SymmetricMatrix3x3<T>::
  SymmetricMatrix3x3(const SymmetricMatrix3x3<T>& src)
  {
    operator=(src);
  }


  template <class T>
  SymmetricMatrix3x3<T>::
  SymmetricMatrix3x3(const Matrix3x3<T>& src)
  {
    if (! Equal(src[0][1], src[1][0]) ||
        ! Equal(src[0][2], src[2][0]) ||
        ! Equal(src[1][2], src[2][1])){
      BEXCEPTION("cannot initialize SymmetricMatrix3x3 from non symmtric "
                 "Matrix3x3: "<<src<<endl);
    }
    Data_[0] = src[0][0];  
    Data_[1] = src[0][1];  
    Data_[2] = src[0][2];  
    Data_[3] = src[1][1];  
    Data_[4] = src[1][2];  
    Data_[5] = src[2][2];
  }


  template <class T>
  SymmetricMatrix3x3<T>::
  SymmetricMatrix3x3(const Matrix<T>& src)
  {
    if (src.num_cols()!=3u || src.num_rows()!=3u){
      BEXCEPTION("cannot initialize SymmetricMatrix3x3 from matrix of different"
                 "size: "<<src.num_rows()<<"x"<<src.num_cols()<<endl);
    }

    if (! Equal(src[0][1], src[1][0]) ||
        ! Equal(src[0][2], src[2][0]) ||
        ! Equal(src[1][2], src[2][1])){
      BEXCEPTION("cannot initialize SymmetricMatrix3x3 from non symmtric "
                 "Matrix3x3: "<<src<<endl);
    }
    Data_[0] = src[0][0];  
    Data_[1] = src[0][1];  
    Data_[2] = src[0][2];  
    Data_[3] = src[1][1];  
    Data_[4] = src[1][2];  
    Data_[5] = src[2][2];
  }


  template <class T>
  SymmetricMatrix3x3<T>::
  ~SymmetricMatrix3x3()
  {
    //std::cout << "destructor: ~SymmetricMatrix3x3()\n";
  }

  template <class T>
  SymmetricMatrix3x3<T>& SymmetricMatrix3x3<T>::
  operator=(const SymmetricMatrix3x3<T>& src)
  {
    memcpy((void *)Data_, (void *)src.Data_, 6*sizeof(T));
    return *this;
  }

  template <class T>
  unsigned int SymmetricMatrix3x3<T>:: 
  SymMatrix3x3ToIndex_(const unsigned row, const unsigned col) const
  {
    // access to (x,y) = access to (y, x): The matrix is symmetric
    // switch such that c is always greater equal r
    unsigned r, c;
    if (col>=row){
      r = row; c = col;
    } else {
      r = col; c = row;
    }
    BIASASSERT(c>=r);
    switch (r){
    case 0:
      return c;
      break;
    case 1:
      return c+2;
      break;
    case 2:
      return 5; 
      break;
    }
    BIASABORT;
    return numeric_limits<unsigned>::max();
  }


  template <class T>
  T&  SymmetricMatrix3x3<T>::
  operator()(const unsigned row, const unsigned col)
  {
    return Data_[SymMatrix3x3ToIndex_(row, col)];
  }


  template <class T>
  const T& SymmetricMatrix3x3<T>::
  operator()(const unsigned row, const unsigned col) const
  {
    return Data_[SymMatrix3x3ToIndex_(row, col)];
  }


  template <class T>
  void SymmetricMatrix3x3<T>::
  GetMatrix(Matrix3x3<T>& dst) const
  {
    dst[0][0] = Data_[0];
    dst[0][1] = dst[1][0] = Data_[1];
    dst[0][2] = dst[2][0] = Data_[2];
    dst[1][1] = Data_[3];
    dst[1][2] = dst[2][1] = Data_[4];
    dst[2][2] = Data_[5];
  }


  template <class T>
  Matrix3x3<T> SymmetricMatrix3x3<T>::
  GetMatrix() const
  {
    Matrix3x3<T> tmp;
    GetMatrix(tmp);
    return tmp;
  }


  template <class T>
  int SymmetricMatrix3x3<T>::
  Write(std::ostream& os) const
  {
    os.write((const char*)(Data_), sizeof(T)*6);
    if (!os.good()) return -1;
    return 0;
  }


  template <class T>
  int SymmetricMatrix3x3<T>::
  Read(std::istream& is)
  {
    is.read((char*)(Data_), sizeof(T)*6);
    if (!is.good()) return -1;
    return 0;
  }


  /////////////////////////////////////////////////////////////////////////
  // stream operators
  /////////////////////////////////////////////////////////////////////////
  
  template <class T> BIASMathBase_EXPORT
  std::ostream& operator<<(std::ostream& os, const SymmetricMatrix3x3<T>& mat)
  {
    if (IsConsoleStream(os)){
      os << mat.Data_[0] << "\t" << mat.Data_[1] << "\t" << mat.Data_[2] << endl
         << "--" << "\t" << mat.Data_[3] << "\t" << mat.Data_[4] << endl
         << "--" << "\t" << "--" << "\t" << mat.Data_[5] << endl;
    } else {
      for (int i=0; i<6; i++)
        os << mat.Data_[i] << " ";
    }
    return os;
  }
  

  template <class T> BIASMathBase_EXPORT
  std::istream& operator>>(std::istream& is, SymmetricMatrix3x3<T>& mat)
  {
    /*if (IsConsoleStream(is)){
      string tmp;
      is >> mat.Data_[0] >> mat.Data_[1] >> mat.Data_[2] 
         >> tmp >> mat.Data_[3] >> mat.Data_[4] 
         >> tmp >> tmp >> mat.Data_[5];
         } else {*/
      for (int i=0; i<6; i++)
        is >> mat.Data_[i] ;
      //}
    return is;
  }
  

}

#define INST(type) \
  template class BIASMathBase_EXPORT BIAS::SymmetricMatrix3x3<type>;    \
  template BIASMathBase_EXPORT ostream& BIAS::operator<<<type>(ostream& os, const SymmetricMatrix3x3<type>& mat); \
  template BIASMathBase_EXPORT istream& BIAS::operator>><type>(istream& is, SymmetricMatrix3x3<type>& mat);

INST(unsigned char)
INST(char)
INST(short)
INST(unsigned short)
INST(int)
INST(unsigned int)
INST(float)
INST(double)