itktransformssetparameterstest.cxx

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkTransformsSetParametersTest.cxx,v $
  Language:  C++
  Date:      $Date: 2007-09-05 16:35:04 $
  Version:   $Revision: 1.7 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

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

#include "itkAffineTransform.h"
#include "itkCenteredAffineTransform.h"
#include "itkCenteredEuler3DTransform.h"
#include "itkCenteredRigid2DTransform.h"
#include "itkCenteredSimilarity2DTransform.h"
#include "itkEuler2DTransform.h"
#include "itkEuler3DTransform.h"
#include "itkFixedCenterOfRotationAffineTransform.h"
#include "itkQuaternionRigidTransform.h"
#include "itkRigid2DTransform.h"
#include "itkRigid3DPerspectiveTransform.h"
#include "itkScalableAffineTransform.h"
#include "itkScaleLogarithmicTransform.h"
#include "itkScaleSkewVersor3DTransform.h"
#include "itkScaleTransform.h"
#include "itkSimilarity2DTransform.h"
#include "itkSimilarity3DTransform.h"
#include "itkTranslationTransform.h"
#include "itkVersorTransform.h"
#include "itkAzimuthElevationToCartesianTransform.h"
#include "itkBSplineDeformableTransform.h"
#include "itkElasticBodyReciprocalSplineKernelTransform.h"
#include "itkElasticBodySplineKernelTransform.h"
#include "itkKernelTransform.h"
#include "itkThinPlateR2LogRSplineKernelTransform.h"
#include "itkThinPlateSplineKernelTransform.h"
#include "itkVersorRigid3DTransform.h"
#include "itkVolumeSplineKernelTransform.h"

#include "vnl/vnl_sample.h"

// Generic Kernel Transform Tester
template<class KernelType> int TestKernelTransform(const char *name, KernelType *)
{
  std::cout << name << std::flush;

  typedef typename KernelType::PointSetType KernelPointSetType;

  typename KernelType::Pointer kernel = KernelType::New();
  typename KernelPointSetType::Pointer targetLandmarks =
    KernelPointSetType::New ();
  typename KernelPointSetType::Pointer sourceLandmarks =
    KernelPointSetType::New ();

  targetLandmarks->GetPoints()->Reserve( 4 );
  sourceLandmarks->GetPoints()->Reserve( 4 );

  // Generate some random coordinates
  typedef itk::PointSet<float>  PointSet;
  typedef typename PointSet::PointType PointType;
  typename KernelPointSetType::CoordRepType randomCoords[3];
  for(int i=0; i < 4 ; ++i)
    {
    randomCoords[0] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    randomCoords[1] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    randomCoords[2] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    targetLandmarks->GetPoints()->SetElement(i, randomCoords);

    randomCoords[0] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    randomCoords[1] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    randomCoords[2] = (typename KernelPointSetType::CoordRepType) 
      vnl_sample_uniform((double)-1.0,(double)1.0);
    sourceLandmarks->GetPoints()->SetElement(i, randomCoords);
    }

  kernel->SetSourceLandmarks( sourceLandmarks );
  kernel->SetTargetLandmarks( targetLandmarks );

  unsigned int beginMTime;
  unsigned int endMTime;
  beginMTime = kernel->GetMTime();
  typename KernelType::ParametersType kernelParams = kernel->GetParameters();
  kernelParams[0] = 1.0;
  kernel->SetParameters( kernelParams );
  endMTime = kernel->GetMTime();
  if ( endMTime > beginMTime) 
    {
    std::cout << "PASS" << std::endl;
    return 0;
    }
  else
    {
    std::cout << "FAIL" << std::endl;
    return 1;
    }
}

// Main Program
int itkTransformsSetParametersTest( int , char *[] )
{


  unsigned int beginMTime;
  unsigned int endMTime;


  std::cout << "Begin testing of SetParameters() method for all itkTransforms"
            << std::endl << std::endl;

  std::cout << "AffineTransform->SetParameters() - " << std::flush;
  typedef itk::AffineTransform< double, 3 > Affine;
  Affine::Pointer affine = Affine::New();
  beginMTime = affine->GetMTime();
  Affine::ParametersType affineParams = affine->GetParameters();
  affineParams[0] = 1.0;
  affine->SetParameters( affineParams );
  endMTime = affine->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;


  std::cout << "CenteredAffineTransform->SetParameters() - " << std::flush;
  typedef itk::CenteredAffineTransform< double, 3 > CenteredAffine;
  CenteredAffine::Pointer centeredAffine =
    CenteredAffine::New();
  beginMTime = centeredAffine->GetMTime();
  CenteredAffine::ParametersType centeredAffineParams =
    centeredAffine->GetParameters();
  centeredAffineParams[0] = 1.0;
  centeredAffine->SetParameters( centeredAffineParams );
  endMTime = centeredAffine->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "CenteredEuler3DTransform->SetParameters() - " << std::flush;
  typedef itk::CenteredEuler3DTransform< double > CenteredEuler3D;
  CenteredEuler3D::Pointer centeredEuler3D =
    CenteredEuler3D::New();
  beginMTime = centeredEuler3D->GetMTime();
  CenteredEuler3D::ParametersType centeredEuler3DParams =
    centeredEuler3D->GetParameters();
  centeredEuler3DParams[0] = 1.0;
  centeredEuler3D->SetParameters( centeredEuler3DParams );
  endMTime = centeredEuler3D->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "CenteredRigid2DTransform->SetParameters() - " << std::flush;
  typedef itk::CenteredRigid2DTransform< double > CenteredRigid2D;
  CenteredRigid2D::Pointer centeredRigid2D =
    CenteredRigid2D::New();
  beginMTime = centeredRigid2D->GetMTime();
  CenteredRigid2D::ParametersType centeredRigid2DParams =
    centeredRigid2D->GetParameters();
  centeredRigid2DParams[0] = 1.0;
  centeredRigid2D->SetParameters( centeredRigid2DParams );
  endMTime = centeredRigid2D->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "CenteredSimilarity2DTransform->SetParameters() - " << std::flush;
  typedef itk::CenteredSimilarity2DTransform< double > CenteredSimilarity2D;
  CenteredSimilarity2D::Pointer centeredSimilarity2D =
    CenteredSimilarity2D::New();
  beginMTime = centeredSimilarity2D->GetMTime();
  CenteredSimilarity2D::ParametersType centeredSimilarity2DParams =
    centeredSimilarity2D->GetParameters();
  centeredSimilarity2DParams[0] = 1.0;
  centeredSimilarity2D->SetParameters( centeredSimilarity2DParams );
  endMTime = centeredSimilarity2D->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "Euler2DTransform->SetParameters() - " << std::flush;
  typedef itk::Euler2DTransform< double > Euler2D;
  Euler2D::Pointer euler2D =
    Euler2D::New();
  beginMTime = euler2D->GetMTime();
  Euler2D::ParametersType euler2DParams =
    euler2D->GetParameters();
  euler2DParams[0] = 1.0;
  euler2D->SetParameters( euler2DParams );
  endMTime = euler2D->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "Euler3DTransform->SetParameters() - " << std::flush;
  typedef itk::Euler3DTransform< double > Euler3D;
  Euler3D::Pointer euler3D =
    Euler3D::New();
  beginMTime = euler3D->GetMTime();
  Euler3D::ParametersType euler3DParams =
    euler3D->GetParameters();
  euler3DParams[0] = 1.0;
  euler3D->SetParameters( euler3DParams );
  endMTime = euler3D->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;



  std::cout << "FixedCenteredAffineTransform->SetParameters() - " << std::flush;
  typedef itk::FixedCenterOfRotationAffineTransform< double, 3 > FixedCenteredAffine;
  FixedCenteredAffine::Pointer fixedCenteredAffine =
    FixedCenteredAffine::New();
  beginMTime = fixedCenteredAffine->GetMTime();
  FixedCenteredAffine::ParametersType fixedCenteredAffineParams =
    fixedCenteredAffine->GetParameters();
  fixedCenteredAffineParams[0] = 1.0;
  fixedCenteredAffine->SetParameters( fixedCenteredAffineParams );
  endMTime = fixedCenteredAffine->GetMTime();
  if ( endMTime > beginMTime) 
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;


  std::cout << "QuaternionRigidTransform->SetParameters() - " << std::flush;
  typedef itk::QuaternionRigidTransform< double > QuaternionRigid;
  QuaternionRigid::Pointer quaternionRigid =
    QuaternionRigid::New();
  beginMTime = quaternionRigid->GetMTime();