#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include <iostream>

#include "itkPermuteAxesTransform.h"
#include "vnl/vnl_vector_fixed.h"

 
int main(int ,char *[] )
{

  int i;

  /* Create a 3D identity transformation and show its parameters */
  typedef itk::PermuteAxesTransform<double,3>  TransformType;
  TransformType::Pointer  id3 = TransformType::New();
	TransformType::PermuteOrderArrayType order3, iorder3;
  order3 = id3->GetOrder();
	iorder3 = id3->GetInverseOrder();
  std::cout << "Order from instantiating an identity transform:"
            << std::endl;
	std::cout << order3 << std::endl;
  std::cout << "Inverse order from instantiating an identity transform:"
            << std::endl;
	std::cout << iorder3 << std::endl;

	for (i = 0; i < 3; i++)
		if (order3[i] != i)
			{
			std::cout << "Invalid identity created." <<std::endl;
			return EXIT_FAILURE;
			}

  /* Create and show a simple 3D transform from given parameters and its inverse */
  order3[0] = 2; order3[1] = 0; order3[2] = 1;
  TransformType::Pointer perm3 = TransformType::New();
	perm3->SetOrder(order3);
  for (i = 0; i < 3; i++) 
    {
    order3[i]    = 0.0;
    }
  std::cout << "Instantiation of a given 3D transform:" 
            << std::endl << perm3;

  TransformType::Pointer inverse3 = TransformType::New();
  if(!perm3->GetInverse(inverse3))
      {
      std::cout << "Cannot create transform" << std::endl;
      return EXIT_FAILURE;
      }

  std::cout << "Inverse of the given transform:"
            << std::endl << inverse3;


	/* Check whether the inverses are computed OK */
	//manually compute inversion
	iorder3[0] = 1; iorder3[1] = 2; iorder3[2] = 0;

	if (perm3->GetInverseOrder() != iorder3
			||
			perm3->GetOrder() != inverse3->GetInverseOrder()
			||
			perm3->GetInverseOrder() != inverse3->GetOrder())
			{
			std::cout << "Invalid inverse computed." << std::endl;
			return EXIT_FAILURE;
			}

	perm3->Invert();

	if (perm3->GetOrder() != inverse3->GetOrder()
			||
			perm3->GetInverseOrder() != inverse3->GetInverseOrder() )
			{
			std::cout << "Invalid inverse computed." << std::endl;
			return EXIT_FAILURE;
			}
	
	/* Set back identity transform */
	perm3->SetIdentity();
	if (perm3->GetOrder() != id3->GetOrder())
			{
			std::cout << "Invalid identity set." << std::endl;
			return EXIT_FAILURE;
			}

	/* Set invalid transform and check if it is determined */
	order3[0] = 0;
	order3[1] = 1;
	for (i = -1; i<4; i+=2)
		{
		order3[2] = i;
    try 
      {
      perm3->SetOrder(order3);

      std::cout << "Invalid order accepted." <<std::endl;
      return EXIT_FAILURE;
      }
    catch (...) {}
    }

	/* Transform a point */
	inverse3->GetInverse(perm3); //restore permutation first
  itk::Point<double, 3> u3, v3;
  u3[0] = 3;
  u3[1] = 5;
	u3[2] = -14.2;
  v3 = perm3->TransformPoint(u3);
  std::cout << "Transform a point:" << std::endl
            << v3[0] << " , " << v3[1] << " , " << v3[2] << std::endl;

	if (v3[0] != -14.2
			||
			v3[1] != 3
			||
			v3[2] != 5 )
		{
		std::cout << "Invalid point transform." << std::endl;
		return EXIT_FAILURE;
		}

  /* Transform a vnl_vector */
  vnl_vector_fixed<double, 3> x3, y3;
  x3[0] = 1;
  x3[1] = 2;
	x3[2] = 3;
  y3 = perm3->TransformVector(x3);
  std::cout << "Transform a vnl_vector:" << std::endl
            << y3[0] << " , " << y3[1] <<  " , " << y3[2] << std::endl;

	if (y3[0] != 3
			||
			y3[1] != 1
			||
			y3[2] != 2 )
		{
		std::cout << "Invalid vnl_vector transform." << std::endl;
		return EXIT_FAILURE;
		}

  /* Transform a vector */
  itk::Vector<double, 3> w3, z3;
  w3[0] = 3;
  w3[1] = 5;
	w3[2] = -14.2;
  z3 = perm3->TransformVector(w3);
  std::cout << "Transform a vector:" << std::endl
            << z3[0] << " , " << z3[1] << z3[2] << " , " << std::endl;

	if (z3[0] != -14.2
			||
			z3[1] != 3
			||
			z3[2] != 5 )
		{
		std::cout << "Invalid Vector transform." << std::endl;
		return EXIT_FAILURE;
		}

	/* Transform a Covariant vector */
  itk::CovariantVector<double, 3> c3, d3;
  c3[0] = 3;
  c3[1] = 5;
	c3[2] = -14.2;
  d3 = perm3->TransformCovariantVector(c3);
  std::cout << "Transform a Covariant vector:" << std::endl
            << d3[0] << " , " << d3[1] << " , " << d3[2] << std::endl;

	if (d3[0] != -14.2
			||
			d3[1] != 3
			||
			d3[2] != 5 )
		{
		std::cout << "Invalid Covariant vector transform." << std::endl;
		return EXIT_FAILURE;
		}

  return EXIT_SUCCESS;
}