void LoadFiles(int argc, char* argv[]) {
        itkcmds::itkImageIO<ImageType> io;
        itkcmds::itkImageIO<LabelType> io2;
        _src = io.ReadImageT(argv[1]);
        _dst = io.ReadImageT(argv[2]);
        _dstLabel = io2.ReadImageT(argv[3]);
        _transformOut = argv[4];
        _resampledOut = argv[5];

        cout << "Transform Output: " << _transformOut << endl;
        cout << "Resampled Output: " << _resampledOut << endl;

        ImageType::SizeType szDst = _dst->GetBufferedRegion().GetSize();
        itk::ContinuousIndex<double,3> szIdx;
        for (int i = 0; i < 3; i++) {
            szIdx[i] = szDst[i] / 2.0;
        }
        _dst->TransformContinuousIndexToPhysicalPoint(szIdx, _dstCenter);

        itk::ImageRegionConstIteratorWithIndex<LabelType> labelIter(_dstLabel, _dstLabel->GetBufferedRegion());
        for (labelIter.GoToBegin(); !labelIter.IsAtEnd(); ++labelIter) {
            LabelType::PixelType label = labelIter.Get();
            if (label > 0) {
                _labelIndexes.push_back(labelIter.GetIndex());
            }
        }

        _centerOfRotation.SetSize(ImageType::ImageDimension);
        for (int i = 0; i < 3; i++) {
            _centerOfRotation[i] = _dstCenter[i];
        }
    }
// ------------------------------------------------------------------------
void computeProbImage(const PatchParams &params, unsigned int pnum,
                      unsigned int id, std::string type, ClassifierMap &classifiers,
                      const ValveType::Pointer &valve, const LabelType::Pointer &mask, RealImageType::Pointer &output)
{
    output = RealImageType::New();
    output->SetDirection(mask->GetDirection());
    output->SetSpacing(mask->GetSpacing());
    output->SetOrigin(mask->GetOrigin());
    output->SetRegions(mask->GetLargestPossibleRegion());
    output->Allocate();
    output->FillBuffer(0);

    itk::ImageRegionIterator<LabelType> maskIt(mask, mask->GetLargestPossibleRegion());
    itk::ImageRegionIterator<RealImageType> probIt(output, output->GetLargestPossibleRegion());

    unsigned int count = 0;
    while(!maskIt.IsAtEnd())
    {
        if(maskIt.Get() == 255)
        {
            IndexType index = maskIt.GetIndex();
            PointType point;
            output->TransformIndexToPhysicalPoint(index, point);

            MatrixType feature;
            extractLBPFeature(params, valve, point, feature);

            MatrixType probs;
            IntMatrixType classes;
            classifiers["MV-"+type][pnum]->PredictProbability(feature, classes, probs);

            probIt.Set(probs(0,1));

            count++;
        }


        ++maskIt;
        ++probIt;
    }



}
// ------------------------------------------------------------------------
void FlipImage(const LabelType::Pointer &input, LabelType::Pointer &output)
{
    if(!output) output = LabelType::New();

    ImageType::DirectionType outputDirection = input->GetDirection();

    typedef itk::PermuteAxesImageFilter<LabelType> FlipperType;
    FlipperType::PermuteOrderArrayType axes;
    axes[0] = 1;
    axes[1] = 0;
    axes[2] = 2;

    FlipperType::Pointer flipper = FlipperType::New();
    flipper->SetInput(input);
    flipper->SetOrder(axes);
    flipper->Update();

    output = flipper->GetOutput();
    output->SetDirection(outputDirection);

}
int main(int argc, char* argv[])
{
	//if(argc < 5){
	//	std::cout<<"Usage1: darpa_tracer <Global_Centroids_List> <DAPI_Montage_File> <GFP_Montage_File> <Seg_Params_File> \n";
	//	return 0;
	//}
	//Input: Somas_file, nucleus_montage, trace_channel_montage, nuc_seg_parameters
	//std::fstream soma_centroid_file;
	//soma_centroid_file.open(argv[1], std::fstream::in);
	//std::vector<centroids> centroid_list;
	//while (soma_centroid_file.good()){
	//	centroids new_centroid;
	//	soma_centroid_file >> new_centroid.x_d >> new_centroid.y_d >> new_centroid.z_d;
	//	centroid_list.push_back( new_centroid );
	//}
	//soma_centroid_file.close();

	std::vector< itk::Index<3> > centroid_list;
	std::vector< itk::Index<3> > all_centroid_list;
	//vtkSmartPointer<vtkTable> global_centroids = ftk::LoadTable(argv[1]);
	vtkSmartPointer<vtkTable> global_centroids = ftk::LoadTable("D:\\11_10_selective_tracing\\Global_centroids.txt");
	for(int r=0; r<(int)global_centroids->GetNumberOfRows(); ++r)
	{
		int cx = global_centroids->GetValue(r, 0).ToInt();
		int cy = global_centroids->GetValue(r, 1).ToInt();
		int cz = global_centroids->GetValue(r, 2).ToInt();

		itk::Index<3> all_cen;
		all_cen[0] = cx; all_cen[1] = cy; all_cen[2] = cz; 
		all_centroid_list.push_back(all_cen);
		if( (fmod((double)cx,1050)>1000) || (fmod((double)cx,1050)<50) || (fmod((double)cy,1050)>1000) || (fmod((double)cy,1050)<50))
		{			
			itk::Index<3> cen;
			cen[0] = cx; cen[1] = cy; cen[2] = cz; 
			centroid_list.push_back(cen);			

		}

	}

	std::cout << "Number of cells to be retraced : " << centroid_list.size() << "\n";

	typedef itk::ImageFileReader<nucImageType> nucReaderType;
	typedef itk::ImageFileReader<gfpImageType> gfpReaderType;
	//nucReaderType::Pointer reader_nuc   = nucReaderType::New();
	//reader_nuc->SetFileName(argv[2]);
	//reader_nuc->Update();
	//nucImageType::Pointer img_nuc   = reader_nuc->GetOutput();
	//gfpReaderType::Pointer reader_trace = gfpReaderType::New();
	//reader_trace->SetFileName(argv[3]);
	//reader_trace->Update();
	//gfpImageType::Pointer img_trace = reader_trace->GetOutput();
	//uint64_t size_trace[3],size_nuc[3];
	//size_nuc[0] = img_nuc->GetLargestPossibleRegion().GetSize()[0];
	//size_nuc[1] = img_nuc->GetLargestPossibleRegion().GetSize()[1];
	//size_nuc[2] = img_nuc->GetLargestPossibleRegion().GetSize()[2];
	//size_trace[0] = img_trace->GetLargestPossibleRegion().GetSize()[0];
	//size_trace[1] = img_trace->GetLargestPossibleRegion().GetSize()[1];
	//size_trace[2] = img_trace->GetLargestPossibleRegion().GetSize()[2];
	//if( size_trace[0]!=size_nuc[0] || size_trace[1]!=size_nuc[1] || size_trace[2]!=size_nuc[2] ) return EXIT_FAILURE;

//	//long int a=0;
//	//while( a<centroid_list.size() ){
//	#pragma omp parallel for num_threads(12)
//	for( long int a=0; a<centroid_list.size(); ++a ){
//	//for( long int a=0; a<5; ++a ){
//		int x, y, z;
//		x = centroid_list[a][0];
//		y = centroid_list[a][1];
//		z = centroid_list[a][2];
//
//		nucImageType::IndexType start;
//		start[0] = ((x - 200)>0) ? (x - 200):0;
//		start[1] = ((y - 200)>0) ? (y - 200):0;
//		start[2] = ((z - 100) >0) ? (z - 100) :0;
//
//		gfpImageType::IndexType start2;
//		start2[0] = ((x - 200)>0) ? (x - 200):0;
//		start2[1] = ((y - 200)>0) ? (y - 200):0;
//		start2[2] = ((z - 100) >0) ? (z - 100) :0;
//
//		nucImageType::SizeType size;
//		size[0] = ((x+200)<size_nuc[0]) ? 400 : (200+size_trace[0]-x-1); 
//		size[1] = ((y+200)<size_nuc[1]) ? 400 : (200+size_trace[1]-y-1);
//		size[2] = ((z+100)<size_nuc[2]) ? 200 : (100+size_trace[2]-z-1);
//
//		gfpImageType::SizeType size2;
//		size2[0] = ((x+200)<size_trace[0]) ? 400 : (200+size_trace[0]-x-1);
//		size2[1] = ((y+200)<size_trace[1]) ? 400 : (200+size_trace[1]-y-1);
//		size2[2] = ((z+100)<size_trace[2]) ? 200 : (100+size_trace[2]-z-1);
//
//		std::ostringstream output_filename_stream;
//
//		nucImageType::RegionType desiredRegion;
//		desiredRegion.SetSize(size);
//		desiredRegion.SetIndex(start);
//
//		gfpImageType::RegionType desiredRegion2;
//		desiredRegion2.SetSize(size2);
//		desiredRegion2.SetIndex(start2);
//
//		typedef itk::RegionOfInterestImageFilter< nucImageType, nucImageType > ROIFilterType;
//		typedef itk::RegionOfInterestImageFilter< gfpImageType, gfpImageType > ROIFilterType2;
//		ROIFilterType::Pointer ROIfilter = ROIFilterType::New();
//		ROIfilter->SetRegionOfInterest(desiredRegion);
//		ROIfilter->SetInput(img_nuc);
//		ROIfilter->Update();
//		nucImageType::Pointer img = ROIfilter->GetOutput();
//
//		ROIFilterType2::Pointer ROIfilter2 = ROIFilterType2::New();
//		ROIfilter2->SetRegionOfInterest(desiredRegion2);
//		ROIfilter2->SetInput(img_trace);
//		ROIfilter2->Update();
//		gfpImageType::Pointer img_tr = ROIfilter2->GetOutput();
//
//		//itk::CastImageFilter<gfpImageType, nucImageType>::Pointer caster = itk::CastImageFilter<gfpImageType, nucImageType>::New();
//		//caster->SetInput(img_tr);
//		//itk::ImageFileWriter<nucImageType>::Pointer writer2 = itk::ImageFileWriter<nucImageType>::New();
//		itk::ImageFileWriter<gfpImageType>::Pointer writer2 = itk::ImageFileWriter<gfpImageType>::New();
//		std::stringstream ss;
//		ss << "gfp_image" << x << "_" << y << "_" << z << ".mhd";
//		std::string file_output;
//		file_output = ss.str();
//		writer2->SetFileName(file_output.c_str());
//		writer2->SetInput(img_tr);
//		writer2->Update();
//
//		//Run Nucleus Segmentation
//		clock_t startTimer = clock();
//		std::cout<<"Starting segmentation\n";
//		unsigned char *in_Image;
//		in_Image = (unsigned char *) malloc (size[0]*size[1]*size[2]);
//		if( in_Image == NULL ){
//			std::cerr<<"Nucleus Seg failed because malloc failed\n";
//			continue;
//		}
//		memset(in_Image/*destination*/,0/*value*/,size[0]*size[1]*size[2]*sizeof(unsigned char)/*num bytes to move*/);
//		typedef itk::ImageRegionConstIterator< nucImageType > ConstIteratorType;
//		ConstIteratorType pix_buf( img, img->GetRequestedRegion() );
//		uint64_t ind=0;
//		for ( pix_buf.GoToBegin(); !pix_buf.IsAtEnd(); ++pix_buf, ++ind )
//			in_Image[ind]=(pix_buf.Get());
//		yousef_nucleus_seg *NucleusSeg = new yousef_nucleus_seg();
//		NucleusSeg->readParametersFromFile(argv[4]);
//		NucleusSeg->setDataImage(in_Image,size[0],size[1],size[2],"/home/gramak/Desktop/11_10_tracing/montage_kt11306_w410DAPIdsu.mhd");
//		NucleusSeg->runBinarization();
//		try 
//		{
//			std::cout<<"Starting seed detection\n";
//			NucleusSeg->runSeedDetection();
//		}
//		catch( bad_alloc & excp )
//		{
//			std::cout<<"You have requested more memory than "
//			<<"what is currently available in this "
//			<<"system, please try again with a smaller "
//			<<"input image\n";
//		}
//		catch( itk::ExceptionObject & excp )
//		{
//			std::cout<<"Error: " << excp <<std::endl;
//		}
//		NucleusSeg->runClustering();
//		unsigned short *output_img;
///*		if(NucleusSeg->isSegmentationFinEnabled())
//		{
//			NucleusSeg->runAlphaExpansion();
//			output_img=NucleusSeg->getSegImage();
//		} 
//		else
//*/
//		output_img=NucleusSeg->getClustImage();
//		std::cout<<"Done with nucleus segmentation for image "<<a<<std::endl;
//
//		LabelType::Pointer image = LabelType::New();
//		LabelType::PointType origin;
//		origin[0] = start[0]; //Is this OK?
//		origin[1] = start[1];
//		origin[2] = start[2];
//		image->SetOrigin( origin );
//		LabelType::IndexType start1;
//		start1[0] = 0;
//		start1[1] = 0;
//		start1[2] = 0;
//		LabelType::SizeType size1;
//		size1[0] = size[0];
//		size1[1] = size[1];
//		size1[2] = size[2];
//		LabelType::RegionType region;
//		region.SetSize ( size1  );
//		region.SetIndex( start1 );
//		image->SetRegions( region );
//		image->Allocate();
//		image->FillBuffer(0);
//		image->Update();
//
//		typedef itk::ImageRegionIteratorWithIndex< LabelType > IteratorType;
//		IteratorType iterator1(image,image->GetRequestedRegion());
//		for(uint64_t i=0; i<(size[0]*size[1]*size[2]); ++i)
//		{
//			unsigned short val = (unsigned short)output_img[i];
//			iterator1.Set(val);
//			++iterator1;
//		}
//
//		std::stringstream ss1;
//		ss1 << "soma_label"<< x << "_" << y << "_" << z << ".tif";
//		std::string file_output1;
//		file_output1 = ss1.str();
//		itk::ImageFileWriter<LabelType>::Pointer writer = itk::ImageFileWriter<LabelType>::New();
//		writer->SetFileName(file_output1);
//		writer->SetInput(image);
//		writer->Update();
//		delete NucleusSeg;
//	}

	long int a=0;
	int num_to_be_traced = centroid_list.size();
	std::cout << "Deleting duplicated seeds....  \n";
	while( a<centroid_list.size() )
	{
		//Run Multiple Neuron Tracer
		int x, y, z;
		x = centroid_list[a][0];
		y = centroid_list[a][1];
		z = centroid_list[a][2];
		if(x == -1)
		{
			++a;
			continue;
		}
		itk::Index<3> centroid;
		centroid[0] = ((x - 200)>0) ? 200:x; 
		centroid[1] = ((y - 200)>0) ? 200:y;
		centroid[2] = ((z - 100) >0) ? 100:z;
		std::stringstream ss1;
		ss1 << "D:\\11_10_selective_tracing\\soma_label"<< centroid_list.at(a)[0] << "_" << centroid_list.at(a)[1] << "_" << centroid_list.at(a)[2] << ".tif";
		std::string file_output1;
		file_output1 = ss1.str();
		itk::ImageFileReader<LabelType>::Pointer reader = itk::ImageFileReader<LabelType>::New();
		reader->SetFileName(file_output1);
		reader->Update();
		LabelType::Pointer image = reader->GetOutput();
		std::cout << image->GetBufferedRegion().GetSize() << "\n";
		typedef itk::ImageRegionIteratorWithIndex< LabelType > IteratorType;
		IteratorType iterator1(image,image->GetRequestedRegion());

		std::vector< itk::Index<3> > soma_centroids;
		std::vector< itk::Index<3> > soma_centroids_to_be_del;
		std::vector<unsigned short> label_vec;
		std::vector<uint64_t> delete_index;
		for(uint64_t ctr =0; ctr<all_centroid_list.size() ; ++ctr)
		{
			itk::Index<3> cen =  all_centroid_list[ctr];
			if(cen[0] == -1) continue;
			if(abs((double)(cen[0]-x))<200 && abs((double)(cen[1]-y))<200 && abs((double)(cen[2]-z))<100 )
			{
				bool centroid_not_found = true;
				itk::Index<3> centroid2;
				centroid2[0] = centroid[0] + cen[0] - x; 
				centroid2[1] = centroid[1] + cen[1] - y;
				centroid2[2] = centroid[2] + cen[2] - z;
				LabelType::IndexType centroid_index;
				centroid_index[0] = centroid2[0]; centroid_index[1] = centroid2[1]; centroid_index[2] = centroid2[2];
				iterator1.SetIndex( centroid_index );
				unsigned short centroid_label = iterator1.Get();
				for(int b=0; b<label_vec.size(); ++b)
				{
					if( label_vec.at(b)==centroid_label )
					{
						centroid_not_found = false;
						break;
					}
				}
				if( centroid_not_found )
				{
					label_vec.push_back( centroid_label );
					soma_centroids.push_back( centroid2 );
				}
				if( !centroid_not_found )
				{
					delete_index.push_back( ctr );
					soma_centroids_to_be_del.push_back( cen );
				}
			}
		}

		if( delete_index.size() )
		{
			std::sort(delete_index.begin(), delete_index.end(), myfunction);
			for( uint64_t b=0; b<delete_index.size(); ++b )
				all_centroid_list[delete_index[b]].Fill(-1);
			delete_index.clear();
			for( uint64_t b=0; b<soma_centroids_to_be_del.size(); ++b )
			{
				itk::Index<3> centroid2 = soma_centroids_to_be_del.at(b);
				for( uint64_t c=0; c<centroid_list.size(); ++c )
				{
					itk::Index<3> centroid3 = centroid_list.at(c);
					if( centroid2[0]==centroid3[0] && centroid2[1]==centroid3[1] && centroid2[2]==centroid3[2] )
					{
						delete_index.push_back( c );
						break;
					}
				}
			}
			std::sort(delete_index.begin(), delete_index.end(), myfunction);
			for( uint64_t b=0; b<delete_index.size(); ++b )
			{
				centroid_list[delete_index[b]].Fill(-1);
				--num_to_be_traced;
			}
			std::cout<<"Number of cells to be retraced : "<<num_to_be_traced << " after "<<a<<" processed\n";
		}
		++a;
	}
	std::cout << "Deleting duplicated seeds done !! \n";

		//std::ostringstream swc_filename_stream;
		//swc_filename_stream << vul_file::strip_extension(argv[3]) << "_" << x << "_" << y << "_" << z << "_ANT.swc";


	//ofstream outFile; 
	//outFile.open("D:\\11_10_selective_tracing\\append_to_swc.txt", ios::out | ios::trunc );
	//if ( !outFile.is_open() )
	//{
	//	std::cerr << "Failed to Load Document: " << outFile << std::endl;
	//	return false;
	//}
	////Write out the features:
	//for( a=0; a<centroid_list.size(); ++a )
	//{
	//	int x, y, z;
	//	x = centroid_list[a][0];
	//	y = centroid_list[a][1];
	//	z = centroid_list[a][2];
	//	if(x == -1) continue;
	//	std::stringstream ssx, ssy, ssz;
	//	ssx << x; ssy << y; ssz << z;
	//	outFile << "_Trace_" + ssx.str() + "_" + ssy.str() + "_" + ssz.str() + "_ANT.swc\n";
	//}
	//outFile.close();


	#pragma omp parallel for num_threads(12)
	for( a=0; a<centroid_list.size(); ++a )
	{
		int x, y, z;
		x = centroid_list[a][0];
		y = centroid_list[a][1];
		z = centroid_list[a][2];
		if(x == -1) continue;
		std::cout<< "Tracing from seed point " << x << "_" << y << "_" << z << "\n";
		itk::Index<3> centroid;
		centroid[0] = ((x - 200)>0) ? 200:x; 
		centroid[1] = ((y - 200)>0) ? 200:y;
		centroid[2] = ((z - 100) >0) ? 100:z;
		std::stringstream ss1;
		ss1 << "D:\\11_10_selective_tracing\\soma_label"<< centroid_list.at(a)[0] << "_" << centroid_list.at(a)[1] << "_" << centroid_list.at(a)[2] << ".tif";
		std::string file_output1;
		file_output1 = ss1.str();
		itk::ImageFileReader<LabelType>::Pointer reader = itk::ImageFileReader<LabelType>::New();
		reader->SetFileName(file_output1);
		reader->Update();
		LabelType::Pointer image = reader->GetOutput();

		itk::ImageFileReader<gfpImageType>::Pointer reader2 = itk::ImageFileReader<gfpImageType>::New();
		std::stringstream ss;
		ss << "D:\\11_10_selective_tracing\\gfp_image" << x << "_" << y << "_" << z << ".mhd";
		std::string file_output;
		file_output = ss.str();
		reader2->SetFileName(file_output.c_str());
		reader2->Update();
		gfpImageType::Pointer img_tr = reader2->GetOutput();

		std::vector< itk::Index<3> > soma_centroids;      
		for(int ctr =0; ctr<all_centroid_list.size() ; ++ctr)
		{
			itk::Index<3> cen =  all_centroid_list[ctr];
			if(cen[0] == -1) continue;
			if(abs((double)(cen[0]-x))<=200 && abs((double)(cen[1]-y))<=200 && abs((double)(cen[2]-z))<=100 )
			{
				itk::Index<3> centroid2;
				centroid2[0] = centroid[0] + cen[0] - x; //Is there a reason why x and y are flipped?
				centroid2[1] = centroid[1] + cen[1] - y;
				centroid2[2] = centroid[2] + cen[2] - z;
				soma_centroids.push_back(centroid2);
			}
		}

		MultipleNeuronTracer * MNT = new MultipleNeuronTracer();
		MNT->LoadCurvImage_1(img_tr, 1);
		MNT->ReadStartPoints_1(soma_centroids, 1);
		MNT->SetCostThreshold(600);
		MNT->LoadSomaImage_1(image);
		MNT->RunTracing();
		/*MNT->WriteSWCFile(std::string(swc_filename_stream.str()), 1);*/
		
		std::stringstream ssx, ssy, ssz;
		ssx << x; ssy << y; ssz << z;
		MNT->WriteSWCFile("D:\\11_10_selective_tracing\\_Trace_" + ssx.str() + "_" + ssy.str() + "_" + ssz.str() + "_ANT.swc", 1);

		delete MNT;
	}

}
    void RunRegistration() {
        _transform = TransformType::New();
        OptiReporter::Pointer optiReporter = OptiReporter::New();
        Metric::Pointer metric = Metric::New();
        metric->SetFixedImage(_dst);
        bool useIndexes = false;
        if (useIndexes) {
            _centerOfRotation.SetSize(ImageType::ImageDimension);
            for (int i = 0; i < ImageType::ImageDimension; i++) {
                _centerOfRotation[i] = i;
            }
            itk::ImageRegionConstIteratorWithIndex<LabelType> labelIter(_dstLabel, _dstLabel->GetBufferedRegion());
            int nPixels = 0;
            for (labelIter.GoToBegin(); !labelIter.IsAtEnd(); ++labelIter) {
                LabelType::PixelType label = labelIter.Get();
                if (label > 0) {
                    _labelIndexes.push_back(labelIter.GetIndex());
                    for (int i = 0; i < ImageType::ImageDimension; i++) {
                        _centerOfRotation[i] += labelIter.GetIndex()[i];
                    }
                    nPixels ++;
                }
            }
            for (int i = 0; i < ImageType::ImageDimension; i++) {
                _centerOfRotation[i] /= nPixels;
            }
            metric->SetFixedImageIndexes(_labelIndexes);
            _transform->SetFixedParameters(_centerOfRotation);
        } else {
            metric->SetFixedImageRegion(_dst->GetBufferedRegion());
            metric->SetUseAllPixels(true);
            _centerOfRotation.SetSize(ImageType::ImageDimension);
            for (int i = 0; i < 3; i++) {
                _centerOfRotation[i] = _dstCenter[i];
            }
            _transform->SetFixedParameters(_centerOfRotation);
        }

        cout << "Fixed Parameters: " << _centerOfRotation << endl;

        metric->SetMovingImage(_src);
        metric->SetInterpolator(Interpolator::New());
        metric->SetTransform(_transform);
        metric->Initialize();

        Optimizer::Pointer opti = Optimizer::New();
        opti->SetCostFunction(metric);
        Optimizer::ScalesType scales;
        scales.SetSize(TransformType::ParametersDimension);
        scales.Fill(1);
        if (_method == "affine") {
            cout << "apply affine scaling ..." << endl;
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (i == j) {
                        scales[3*i+j] = 160;
                    } else {
                        scales[3*i+j] = 30;
                    }
                }
            }
            scales[9] = scales[10] = scales[11] = 0.1;
        } else if (_method == "scale") {
            scales[0] = scales[1] = scales[2] = 30;
            scales[3] = scales[4] = scales[5] = .5;
            scales[6] = scales[7] = scales[8] = 100;
        } else if (_method == "similar") {
            scales[0] = scales[1] = scales[2] = 10;
            scales[3] = scales[4] = scales[5] = 0.5;
            scales[6] = 100;
        }
        opti->SetScales(scales);

        const int maxIters = 100;
#ifdef USE_CG_OPTIMIZER
        opti->SetMaximumIteration(maxIters);
        opti->SetMaximumLineIteration(10);
        opti->SetUseUnitLengthGradient(true);
        opti->SetStepLength(1);
        opti->SetToFletchReeves();
#endif

#ifdef USE_GD_OPTIMIZER
        opti->SetNumberOfIterations(maxIters);
        opti->SetMinimumStepLength(1e-4);
        opti->SetMaximumStepLength(3);
        opti->SetRelaxationFactor(.5);
        opti->SetGradientMagnitudeTolerance(1e-4);
#endif

        opti->SetInitialPosition(_transform->GetParameters());
        opti->AddObserver(itk::StartEvent(), optiReporter);
        opti->AddObserver(itk::IterationEvent(), optiReporter);
        opti->StartOptimization();
        cout << "Current Cost: " << opti->GetValue() << endl;
        _transformResult = opti->GetCurrentPosition();
        _transform->SetParameters(opti->GetCurrentPosition());
    }