itkorientimagefiltertest2.cxx

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

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkOrientImageFilterTest2.cxx,v $
  Language:  C++
  Date:      $Date: 2007-08-10 14:34:02 $
  Version:   $Revision: 1.2 $

  Copyright (c) Insight Software 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 "itkImage.h"
#include "itkSpatialOrientation.h"
#include "itkOrientImageFilter.h"
#include "itkIOCommon.h"
#include <vnl/vnl_sample.h>

typedef itk::Image<std::string,3> ImageType;

typedef itk::OrientImageFilter<ImageType,ImageType> OrientImageFilterType;
typedef OrientImageFilterType::PermuteOrderArrayType PermuteOrderArrayType;

static void PrintImg(ImageType::Pointer img,
                     const OrientImageFilterType::PermuteOrderArrayType &permute)
{
// Print the volume
  ImageType::IndexType Index;  
  for(Index[1] = 0; Index[1] < 4; Index[1]++)
    {
    for(Index[2] = 0; Index[2] < 4; Index[2]++)
      {
      for(Index[0] = 0; Index[0] < 4; Index[0]++)
        {
        std::cerr << img->GetPixel(Index).c_str()[permute[0]]
                  << img->GetPixel(Index).c_str()[permute[1]]          
                  << img->GetPixel(Index).c_str()[permute[2]]          
                  << " ";
        }
      std::cerr <<  " | ";
      }
    std::cerr << std::endl;
    }
  std::cerr << std::endl;
}

ImageType::Pointer CreateAxialImage()
{
  const ImageType::SizeType imageSize = {{4,4,4}};
  ImageType::IndexType imageIndex = {{0,0,0}};
  ImageType::RegionType region;
  region.SetSize(imageSize);
  region.SetIndex(imageIndex);
  ImageType::Pointer img = ImageType::New();
  img->SetLargestPossibleRegion(region);
  img->SetBufferedRegion(region);
  img->SetRequestedRegion(region);
  img->Allocate();

  std::string row, column, slice, label;
  for(imageIndex[2] = 0; imageIndex[2] < 4; imageIndex[2]++)
    {
    if (imageIndex[2] < 2)
      {
      slice = "I";
      }
    else
      {
      slice = "S";
      }
    for(imageIndex[1] = 0; imageIndex[1] < 4; imageIndex[1]++)
      {
      if (imageIndex[1] < 2)
        {
        row = "A";
        }
      else
        {
        row = "P";
        }
      for(imageIndex[0] = 0; imageIndex[0] < 4; imageIndex[0]++)
        {
        if (imageIndex[0] < 2)
          {
          column = "R";
          }
        else
          {
          column = "L";
          }
        label = column + row + slice;
        img->SetPixel(imageIndex, label);
        }
      }
    }

  return img;
}

ImageType::Pointer CreateCoronalImage()
{
  const ImageType::SizeType imageSize = {{4,4,4}};
  ImageType::IndexType imageIndex = {{0,0,0}};
  ImageType::RegionType region;
  region.SetSize(imageSize);
  region.SetIndex(imageIndex);
  ImageType::Pointer img = ImageType::New();
  img->SetLargestPossibleRegion(region);
  img->SetBufferedRegion(region);
  img->SetRequestedRegion(region);
  img->Allocate();

  ImageType::DirectionType imageDirection;
  imageDirection[0][0] = 1;
  imageDirection[1][0] = 0;
  imageDirection[2][0] = 0;

  imageDirection[0][1] = 0;
  imageDirection[1][1] = 0;
  imageDirection[2][1] = -1;

  imageDirection[0][2] = 0;
  imageDirection[1][2] = 1;
  imageDirection[2][2] = 0;
  img->SetDirection(imageDirection);  
  std::string row, column, slice, label;
  for(imageIndex[2] = 0; imageIndex[2] < 4; imageIndex[2]++)
    {
    if (imageIndex[2] < 2)
      {
      slice = "A";
      }
    else
      {
      slice = "P";
      }
    for(imageIndex[1] = 0; imageIndex[1] < 4; imageIndex[1]++)
      {
      if (imageIndex[1] < 2)
        {
        row = "S";
        }
      else
        {
        row = "I";
        }
      for(imageIndex[0] = 0; imageIndex[0] < 4; imageIndex[0]++)
        {
        if (imageIndex[0] < 2)
          {
          column = "R";
          }
        else
          {
          column = "L";
          }
        label = column + row + slice;
        img->SetPixel(imageIndex, label);
        }
      }
    }

  return img;
}

int itkOrientImageFilterTest2(int,char *[])
{
  ImageType::Pointer axialimage = CreateAxialImage();
  std::cerr << "Original" << std::endl;
  OrientImageFilterType::PermuteOrderArrayType permute;
  permute[0] = 0; permute[1] = 1; permute[2] = 2;
  PrintImg(axialimage, permute);

  itk::OrientImageFilter<ImageType,ImageType>::Pointer orienter =
    itk::OrientImageFilter<ImageType,ImageType>::New();

  orienter->UseImageDirectionOn();
  orienter->SetInput(axialimage);

  // try permuting axes
  orienter->SetDesiredCoordinateOrientationToAxial();
  orienter->Update();

  ImageType::Pointer axial  = orienter->GetOutput();
  std::cerr << "axial" << std::endl;
  std::cout << "PermuteOrder: " << orienter->GetPermuteOrder() << std::endl;
  std::cout << "FlipAxes: " << orienter->GetFlipAxes() << std::endl;
  orienter->GetOutput()->Print (std::cout);
  PrintImg(axial, orienter->GetPermuteOrder());

  // go to coronal
  orienter = itk::OrientImageFilter<ImageType,ImageType>::New();
  orienter->UseImageDirectionOn();
  orienter->SetInput(axialimage);
  orienter->SetDesiredCoordinateOrientationToCoronal();
  orienter->Update();

  ImageType::Pointer coronal  = orienter->GetOutput();
  std::cerr << "coronal" << std::endl;
  orienter->GetOutput()->Print (std::cout);
  std::cout << "PermuteOrder: " << orienter->GetPermuteOrder() << std::endl;
  std::cout << "FlipAxes: " << orienter->GetFlipAxes() << std::endl;
  PrintImg(coronal, orienter->GetPermuteOrder());

  // go to sagittal
  orienter = itk::OrientImageFilter<ImageType,ImageType>::New();
  orienter->UseImageDirectionOn();
  orienter->SetInput(axialimage);
  orienter->SetDesiredCoordinateOrientationToSagittal();
  orienter->Update();

  ImageType::Pointer sagittal  = orienter->GetOutput();
  std::cerr << "sagittal" << std::endl;
  std::cout << "PermuteOrder: " << orienter->GetPermuteOrder() << std::endl;
  std::cout << "FlipAxes: " << orienter->GetFlipAxes() << std::endl;
  orienter->GetOutput()->Print (std::cout);
  PrintImg(sagittal, orienter->GetPermuteOrder());

// ----------------------------------------------------------------------

  orienter->SetInput(axialimage);
  std::cout << "RIP" << std::endl;
  orienter->SetDesiredCoordinateOrientation(itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RIP);
  orienter->Update();
  std::cout << orienter->GetOutput()->GetDirection() << std::endl;

  std::cout << "LIP" << std::endl;
  orienter->SetDesiredCoordinateOrientation(itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_LIP);