#include <stdio.h>
#include "itkRigid2DTransform.h"
#include "itkLandmarkBasedTransformInitializer.h"
#include "itkImage.h"
#include "itkRGBPixel.h"
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkVectorResampleImageFilter.h"
#include "itkVectorLinearInterpolateImageFunction.h"

int main( int argc, char *argv[] )
{
	double x,y,z;
	
	if( argc < 12 )
    	{
		std::cerr << "Missing Parameters " << std::endl;
		std::cerr << "Usage: " << argv[0] << std::endl;
		std::cerr << " inputFixedImage " << std::endl;
		std::cerr << " inputMovingImage " << std::endl;
		std::cerr << " outputImage " << std::endl;
		std::cerr << " fixed_x1 " << std::endl;
		std::cerr << " fixed_y1 " << std::endl;
		std::cerr << " fixed_x2 " << std::endl;
		std::cerr << " fixed_y2 " << std::endl;
		std::cerr << " moving_x1 " << std::endl;
		std::cerr << " moving_y1 " << std::endl;
		std::cerr << " moving_x2 " << std::endl;
		std::cerr << " moving_y2 " << std::endl;
	}

	const unsigned int Dimension = 2;
	typedef   itk::RGBPixel< unsigned char >        RGBPixelType;
	
	typedef   itk::Image< RGBPixelType, Dimension > FixedImageType;
	typedef   itk::Image< RGBPixelType, Dimension > MovingImageType;
	
	typedef itk::Rigid2DTransform< double > TransformType;
	TransformType::Pointer transform = TransformType::New();

	typedef itk::LandmarkBasedTransformInitializer< TransformType, 
            FixedImageType, MovingImageType > TransformInitializerType;
	TransformInitializerType::Pointer initializer = TransformInitializerType::New();

	TransformInitializerType::LandmarkPointContainer fixedLandmarks;
    	TransformInitializerType::LandmarkPointContainer movingLandmarks;
    	TransformInitializerType::LandmarkPointType point;
	
	point[0] = atof(argv[4]);
	point[1] = atof(argv[5]);
	fixedLandmarks.push_back(point);
	
	point[0] = atof(argv[6]);
	point[1] = atof(argv[7]);
	fixedLandmarks.push_back(point);
	
	point[0] = atof(argv[8]);
	point[1] = atof(argv[9]);
	movingLandmarks.push_back(point);
	
	point[0] = atof(argv[10]);
	point[1] = atof(argv[11]);
	movingLandmarks.push_back(point);

	typedef itk::ImageFileReader< FixedImageType >  FixedReaderType;
	FixedReaderType::Pointer freader = FixedReaderType::New();
	freader->SetFileName( argv[1] );

	typedef itk::ImageFileReader< MovingImageType >  MovingReaderType;
	MovingReaderType::Pointer mreader = MovingReaderType::New();
	mreader->SetFileName( argv[2] );

	try
    	{
		freader->Update();
	}
      	catch( itk::ExceptionObject & excp )
    	{
	    	std::cerr << "Exception thrown " << std::endl;
	    	std::cerr << excp << std::endl;
    	}

	//FixedImageType::PointType center;
	//center[0] = 0;
	//center[0] = 0;
	transform->SetIdentity();

	initializer->SetFixedLandmarks( fixedLandmarks );
	initializer->SetMovingLandmarks( movingLandmarks );
	//initializer->SetFixedLandmarks( movingLandmarks );
	//initializer->SetMovingLandmarks( fixedLandmarks );

	initializer->SetFixedImage(freader->GetOutput());
    	initializer->SetMovingImage(mreader->GetOutput());

	initializer->SetTransform(transform);
    	initializer->InitializeTransform();

	typedef itk::VectorResampleImageFilter<
		MovingImageType,MovingImageType> ResampleType;
      	ResampleType::Pointer resample = ResampleType::New();

	resample->SetTransform( transform );

	typedef itk::VectorLinearInterpolateImageFunction< 
                       MovingImageType, double >  InterpolatorType;
	InterpolatorType::Pointer interpolator = InterpolatorType::New();

	resample->SetInterpolator( interpolator );

	FixedImageType::Pointer fixedImage = freader->GetOutput();
	
	resample->SetSize(    fixedImage->GetLargestPossibleRegion().GetSize() );
	resample->SetOutputOrigin(  fixedImage->GetOrigin() );
      	resample->SetOutputSpacing( fixedImage->GetSpacing() );
      	resample->SetDefaultPixelValue( 100 );
	
	
		
	
	
	typedef itk::ImageFileWriter< MovingImageType > WriterType;
	WriterType::Pointer writer = WriterType::New();
	
	writer->SetFileName( argv[3] );
	
	resample->SetInput(mreader->GetOutput());
	writer->SetInput(resample->GetOutput());

	try
    	{
		writer->Write();
	}
      	catch( itk::ExceptionObject & excp )
    	{
	    	std::cerr << "Exception thrown " << std::endl;
	    	std::cerr << excp << std::endl;
    	}

	return 0;
}