#ifndef _itkPermuteAxesTransform_txx
#define _itkPermuteAxesTransform_txx

#include "itkPermuteAxesTransform.h"


namespace itk
{

// Constructor with default arguments
template<class TScalarType, unsigned int NDimensions>
PermuteAxesTransform<TScalarType, NDimensions>::
PermuteAxesTransform():Superclass(NDimensions,0)
{
	this->SetIdentity();
}
    

// Destructor
template<class TScalarType, unsigned int NDimensions>
PermuteAxesTransform<TScalarType, NDimensions>::
~PermuteAxesTransform()
{
  return;
}


// Print self
template<class TScalarType, unsigned int NDimensions>
void
PermuteAxesTransform<TScalarType, NDimensions>::
PrintSelf(std::ostream &os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

	unsigned int j;

  os << indent << "Order: [";
  for( j = 0; j < SpaceDimension - 1; j++ )
    {
    os << m_Order[j] << ", ";
    }
  os << m_Order[j] << "]" << std::endl;

  os << indent << "InverseOrder: [";
  for( j = 0; j < SpaceDimension - 1; j++ )
    {
    os << m_InverseOrder[j] << ", ";
    }
  os << m_InverseOrder[j] << "]" << std::endl;
}


// Transform a point
template<class TScalarType, unsigned int NDimensions>
typename PermuteAxesTransform<TScalarType, NDimensions>::OutputPointType
PermuteAxesTransform<TScalarType, NDimensions>::
TransformPoint(const InputPointType &point) const 
{
	OutputPointType opoint;
	
	for (unsigned int j = 0; j < SpaceDimension; j++)
		{
			opoint[j] = point[ m_Order[j] ];
		}

  return opoint;
}

// Transform a vector
template<class TScalarType, unsigned int NDimensions>
typename PermuteAxesTransform<TScalarType, NDimensions>::OutputVectorType
PermuteAxesTransform<TScalarType, NDimensions>::
TransformVector(const InputVectorType &vect) const 
{
	OutputVectorType ovect;

	for (unsigned int j = 0; j < SpaceDimension; j++)
		{
			ovect[j] = vect[ m_Order[j] ];
		}

  return  ovect;
}


// Transform a vnl_vector_fixed
template<class TScalarType, unsigned int NDimensions>
typename PermuteAxesTransform<TScalarType, NDimensions>::OutputVnlVectorType
PermuteAxesTransform<TScalarType, NDimensions>::
TransformVector(const InputVnlVectorType &vect) const 
{
	OutputVnlVectorType ovect;

	for (unsigned int j = 0; j < SpaceDimension; j++)
		{
			ovect[j] = vect[ m_Order[j] ];
		}

  return  ovect;
}


// Transform a CovariantVector
template<class TScalarType, unsigned int NDimensions>
typename PermuteAxesTransform<TScalarType, NDimensions>::OutputCovariantVectorType
PermuteAxesTransform<TScalarType, NDimensions>::
TransformCovariantVector(const InputCovariantVectorType &vect) const 
{
	OutputCovariantVectorType ovect;

	for (unsigned int j = 0; j < SpaceDimension; j++)
		{
			ovect[j] = vect[ m_Order[j] ];
		}

  return  ovect;
}


//Set the permutation order
template<class TScalarType, unsigned int NDimensions>
void
PermuteAxesTransform<TScalarType, NDimensions>::
SetOrder( const PermuteOrderArrayType& order )
{

  unsigned int j; 

  // check if it the same as current
  if ( m_Order == order ) return;

  // check that input is a rearrangement of the
  // numbers from 0 to ImageDimension - 1
  FixedArray<bool,SpaceDimension> used;
  used.Fill( false );

  for ( j = 0; j < SpaceDimension; j++ )
    {
    if ( order[j] > SpaceDimension - 1 )
      {
      ExceptionObject err(__FILE__, __LINE__);
      err.SetLocation( "PermuteAxesTransform::SetOrder" );
      err.SetDescription( "Order indices is out of range" );
      throw err;
      }
    else if ( used[order[j]] )
      {
      ExceptionObject err(__FILE__, __LINE__);
      err.SetLocation( "PermuteAxesTransform::SetOrder" );
      err.SetDescription( "Order indices must not repeat" );
      throw err;
      }
    used[order[j]] = true;
    }

  // copy to member variable
  m_Order = order;
  for ( j = 0; j < SpaceDimension; j++ )
    {
    m_InverseOrder[m_Order[j]] = j;
    }
  
  this->Modified();
}



//get inverse transform
template<class TScalarType, unsigned int NDimensions>
bool
PermuteAxesTransform<TScalarType, NDimensions>::
GetInverse( Self* inverse) const
{
  if(!inverse)
    {
    return false;
    }

  inverse->m_Order   = m_InverseOrder;
  inverse->m_InverseOrder   = m_Order;

  return true;
}

//set inverse transform
template<class TScalarType, unsigned int NDimensions>
void
PermuteAxesTransform<TScalarType, NDimensions>::
Invert( void )
{
	PermuteOrderArrayType  tmp;

	tmp = m_Order;
  m_Order = m_InverseOrder;
  m_InverseOrder = tmp;
}

// Set the parameters for an Identity transform of this class
template<class TScalarType, unsigned int NDimensions>
void
PermuteAxesTransform<TScalarType, NDimensions>::
SetIdentity()
{
  for ( unsigned int j = 0; j < SpaceDimension; j++ )
    {
    m_Order[j] = j;
    m_InverseOrder[m_Order[j]] = j;
    }
}


} // namespace

#endif