Tensor3D.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 <Base/Common/W32Compat.hh>
#include <math.h>
#include "Tensor3D.hh"

using namespace BIAS;
using namespace std;

template <class T>
Tensor3D<T>::Tensor3D()
  : _Data(NULL), _DataArray(NULL), _Dim1(0), _Dim2(0), _Dim3(0)
{}

template <class T>
Tensor3D<T>::Tensor3D(const int i, const int j, const int k, 
                      const T& def)
  : _Data(NULL), _DataArray(NULL), _Dim1(0), _Dim2(0), _Dim3(0)
{
  NewSize(i, j, k, def);
}

template <class T>
Tensor3D<T>::Tensor3D(const Tensor3D<T>& t)
{
  *this=t;
}

template <class T>
Tensor3D<T>::~Tensor3D()
{
  Destroy();
}

template <class T>
void Tensor3D<T>::NewSize(const int i, const int j, const int k, 
                          const T& def)
{
  BIASASSERT(i>=0);
  BIASASSERT(j>=0);
  BIASASSERT(k>=0);

  if (i!=_Dim1 || j!=_Dim2 || k!=_Dim3){
    Destroy();
    _Dim1=i; // dimension in x direction
    _Dim2=j; // dimension in y direction
    _Dim3=k; // dimension in z direction
    _Size=i*j*k;
    // allocate data
    _Data=new T[_Size];
    // construct data pointer array
    int xyPlaneSize=_Dim1*_Dim2;
    _DataArray=new T**[_Dim3];
    for (int z=0; z<_Dim3; z++){
      _DataArray[z]=new T*[_Dim2];
      for (int y=0; y<_Dim2; y++){
        _DataArray[z][y]=_Data+z*xyPlaneSize+y*_Dim1;
      }
    }
  }
  // now fill with default
  for (int m=0; m<_Size; m++){ 
    _Data[m]=def;
  }
}

template <class T>
void Tensor3D<T>::Destroy()
{
  if (_Data) { delete[] _Data; _Data=NULL; }
  if (_DataArray) {
    for (int z=0; z<_Dim3; z++){
      delete[] _DataArray[z]; _DataArray[z]=NULL;
    }
    delete[] _DataArray; _DataArray=NULL;
  }
  _Dim1=0;
  _Dim2=0;
  _Dim3=0;
  _Size=0;
}

template <class T>
int Tensor3D<T>::GetDim1() const
{ 
  return _Dim1; 
}

template <class T>
int Tensor3D<T>::GetDim2() const
{ 
  return _Dim2; 
}

template <class T>
int Tensor3D<T>::GetDim3() const
{ 
  return _Dim3; 
}

template <class T>
void Tensor3D<T>::SetZero()
{
  memset((void *)_Data, 0, sizeof(T)*_Size);
}

template <class T>
Tensor3D<T>& Tensor3D<T>::operator=(const Tensor3D<T>& t)
{
  NewSize(t.GetDim1(), t.GetDim2(), t.GetDim3());
  memcpy((void *)_Data, (void *)t.GetData(), _Size*sizeof(T));
  return *this;
}

template <class T>
bool Tensor3D<T>::operator==(const Tensor3D<T>& t)
{
  if ( t.GetDim1() != GetDim1() ||
       t.GetDim2() != GetDim2() ||
       t.GetDim3() != GetDim3() ) return false;
  for(int i=0; i<(GetDim1()*GetDim2()*GetDim3()) ; i++)
    if ( t.GetData()[i]!=_Data[i] ) return false;
  return true;    
}


template <class T>
Vector<T> Tensor3D<T>::ToVector()
{
  int rows = GetDim1()*GetDim2()*GetDim3();
  Vector<T> result(rows);

  for(int i=0; i<GetDim1(); i++)
    for(int j=0; j<GetDim2(); j++)
      for(int k=0; k<GetDim3(); k++)
        result[i*GetDim1()*GetDim2() + j*GetDim2() + k] = _DataArray[i][j][k];

  return result;
}


template <class T>
void Tensor3D<T>::SetFromVector(const Vector<T> &v)
{
  BIASASSERT( (int)v.Size() >= GetDim1()*GetDim2()*GetDim3() );
  
  for(int i=0; i<GetDim1(); i++)
    for(int j=0; j<GetDim2(); j++)
      for(int k=0; k<GetDim3(); k++)
        _DataArray[i][j][k] = v[i*GetDim1()*GetDim2() + j*GetDim2() + k];
}


template <class T>
void Tensor3D<T>::Scale(T factor)
{
  for(int i=0; i<_Size; i++)
    _Data[i] = _Data[i] * factor;
}


template <class T>
T Tensor3D<T>::GetLength() const
{
  T Length = 0;
  for(int i=0; i<_Size; i++)
    Length += _Data[i] * _Data[i];
  return Length;
}



#define INST(type) \
template class BIASMathBase_EXPORT BIAS::Tensor3D<type>;\

INST(short)
INST(int)
INST(float)
INST(double)