Lattice.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template <typename TSpace>
inline
typename TSpace::Dimension
DGtal::Lattice<TSpace>::n() const
{ 
  return myN;
}

template <typename TSpace>
inline
typename TSpace::Dimension
DGtal::Lattice<TSpace>::m() const
{
  return myM;
}

// Interface - public :

template <typename TSpace>
inline
void
DGtal::Lattice<TSpace>::selfDisplay ( std::ostream & out ) const
{
  out << "[Lattice n=" << myN << " m=" << myM << "]";
}

template <typename TSpace>
inline
bool
DGtal::Lattice<TSpace>::isValid() const
{
    return true;
}

// Standard services - public :

template <typename TSpace>
inline
DGtal::Lattice<TSpace>::~Lattice()
{
  if ( myX0 != 0 ) delete[] myX0;
  if ( myV != 0 ) delete[] myV;
}


template <typename TSpace>
inline
DGtal::Lattice<TSpace>::Lattice()
  : myN( 0 ), myM( 0 ), myX0( 0 ), myV( 0 )
{
}

template <typename TSpace>
DGtal::Lattice<TSpace>::Lattice ( const Lattice<Space> & other )
  : myN( other.myN ), myM( other.myM ), myX0( 0 ), myV( 0 )
{
  if ( ( myN == 0 ) || ( myM == 0 ) ) return;
  myX0 = new double[ myM ];
  myV = new double[ myM * myN ];
  for ( Dimension j = 0; j < myM; j++ )
    myX0[ j ] = other.myX0[ j ];
  for ( Dimension i = 0; i < myN; i++ )
    {
      for ( Dimension j = 0; j < myM; j++ )
  myV[ m*i + j ] = other.myV[ m*i + j ];
    }
}

template <typename TSpace>
inline
DGtal::Lattice<TSpace> & 
DGtal::Lattice<TSpace>::operator= ( const Lattice<Space> & other )
{
  if ( this != &other )
    {
      if ( ( other.myM != myM ) || ( other.myN != myN ) )
  {
    if ( myX0 != 0 ) delete[] myX0;
    if ( myV != 0 ) delete[] myV;
    myN = other.myN;
    myM = other.myM;
    if ( ( myN == 0 ) || ( myM == 0 ) ) 
      {
        myX0 =0;
        myV = 0;
      }
    else
      {
        myX0 = new double[ myM ];
        myV = new double[ myM * myN ];
      }
  }
      for ( Dimension j = 0; j < myM; j++ )
  myX0[ j ] = other.myX0[ j ];
      for ( Dimension i = 0; i < myN; i++ )
  {
    for ( Dimension j = 0; j < myM; j++ )
      myV[ m*i + j ] = other.myV[ m*i + j ];
  }
    }
  return *this;
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::init( Dimension aN, Dimension aM, double dh )
{
  ASSERT( aN > 0 );
  ASSERT( aM > 0 );
  if ( ( aM != myM ) || ( aN != myN ) )
    {
      myN = aN;
      myM = aM;
      if ( myX0 != 0 ) delete[] myX0;
      if ( myV != 0 ) delete[] myV;
      myX0 = new double[ aM ];
      myV = new double[ aM*aN ];
    }
  for ( Dimension j = 0; j < aM; j++ )
    myX0[ j ] = 0.0;
  for ( Dimension i = 0; i < aN; i++ )
    {
      for ( Dimension j = 0; j < aM; j++ )
  myV[ aM*i + j ] = ( j == ( i % aM ) ) ? dh : 0.0;  
    }
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::clear()
{
  if ( myX0 != 0 ) delete[] myX0;
  if ( myV != 0 ) delete[] myV;
  myX0 = 0;
  myV = 0;
  myN = 0;
  myM = 0;
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::setOrigin( const double* x )
{
  for ( Dimension j = 0; j < myM; j++ )
    myX0[ j ] = x[ j ];
}


template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::setVector( Dimension i, const double* v )
{
  double* off_v = myV + myM*i;
  for ( Dimension j = 0; j < myM; j++ )
    off_v[ j ] = v[ j ];
}


template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::immerse( const Integer* p, double* x ) const
{
  for ( Dimension j = 0; j < myM; j++ )
    x[ j ] = myX0[ j ];

  double* off_v = myV;
  for ( Dimension i = 0; i < myN; i++ )
    {
      Integer pi = p[ i ];
      for ( Dimension j = 0; j < myM; j++ )
  {
    x[ j ] += (*off_v) * pi;
    ++off_v;
  }
    }  
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::immerse( const Point & p, double* x ) const
{
  for ( Dimension j = 0; j < myM; j++ )
    x[ j ] = myX0[ j ];

  double* off_v = myV;
  for ( Dimension i = 0; i < myN; i++ )
    {
      Integer pi = p[ i ];
      for ( Dimension j = 0; j < myM; j++ )
  {
    x[ j ] += (*off_v) * pi;
    ++off_v;
  }
    }  
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::immerse( const Integer* p, float* x ) const
{
  for ( Dimension j = 0; j < myM; j++ )
    x[ j ] = (float) myX0[ j ];

  double* off_v = myV;
  for ( Dimension i = 0; i < myN; i++ )
    {
      Integer pi = p[ i ];
      for ( Dimension j = 0; j < myM; j++ )
  {
    x[ j ] += (float) ((*off_v) * pi);
    ++off_v;
  }
    }  
}

template <typename TSpace>
inline
void 
DGtal::Lattice<TSpace>::immerse( const Point & p, float* x ) const
{
  for ( Dimension j = 0; j < myM; j++ )
    x[ j ] = (float) myX0[ j ];

  double* off_v = myV;
  for ( Dimension i = 0; i < myN; i++ )
    {
      Integer pi = p[ i ];
      for ( Dimension j = 0; j < myM; j++ )
  {
    x[ j ] += (float) ((*off_v) * pi);
    ++off_v;
  }
    }  
}


// Implementation of inline functions                                        //

template <typename TSpace>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
      const Lattice<TSpace> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //