itkOrientImageFilter.h

Go to the documentation of this file.

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

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: itkOrientImageFilter.h,v $
Language:  C++
Date:      $Date: 2009-04-25 12:27:46 $
Version:   $Revision: 1.12 $

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.

=========================================================================*/
#ifndef __itkOrientImageFilter_h
#define __itkOrientImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkIOCommon.h"
#include "itkPermuteAxesImageFilter.h"
#include "itkFlipImageFilter.h"
#include "itkSpatialOrientation.h"
#include "itkSpatialOrientationAdapter.h"
#include <map>
#include <string>

namespace itk {

template<class TInputImage, class TOutputImage>
class ITK_EXPORT OrientImageFilter :
    public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  typedef OrientImageFilter         Self;
  typedef ImageToImageFilter<TInputImage, TOutputImage>
                                    Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  typedef TInputImage                              InputImageType;
  typedef typename InputImageType::Pointer         InputImagePointer;
  typedef typename InputImageType::ConstPointer    InputImageConstPointer;
  typedef typename InputImageType::RegionType      InputImageRegionType;
  typedef typename InputImageType::PixelType       InputImagePixelType;
  typedef TOutputImage                             OutputImageType;
  typedef typename OutputImageType::Pointer        OutputImagePointer;
  typedef typename OutputImageType::ConstPointer   OutputImageConstPointer;
  typedef typename OutputImageType::RegionType     OutputImageRegionType;
  typedef typename OutputImageType::PixelType      OutputImagePixelType;
  typedef SpatialOrientation::ValidCoordinateOrientationFlags
                                                   CoordinateOrientationCode;

  typedef PermuteAxesImageFilter< TInputImage >        PermuterType;
  typedef typename PermuterType::PermuteOrderArrayType PermuteOrderArrayType;

  typedef FlipImageFilter< TInputImage >           FlipperType;
  typedef typename FlipperType::FlipAxesArrayType  FlipAxesArrayType;

  
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  itkNewMacro(Self);

  itkTypeMacro(OrientImageFilter, ImageToImageFilter);

  itkGetEnumMacro(GivenCoordinateOrientation, CoordinateOrientationCode);
  void SetGivenCoordinateOrientation(CoordinateOrientationCode newCode);
  inline void SetGivenCoordinateDirection(const typename TInputImage::DirectionType &GivenDirection)
    {
    SetGivenCoordinateOrientation(
    itk::SpatialOrientationAdapter().FromDirectionCosines(GivenDirection));
    }
  itkGetEnumMacro(DesiredCoordinateOrientation, CoordinateOrientationCode);
  void SetDesiredCoordinateOrientation(CoordinateOrientationCode newCode);
  inline void SetDesiredCoordinateDirection(const typename TOutputImage::DirectionType &DesiredDirection)
    {
    SetDesiredCoordinateOrientation(
    itk::SpatialOrientationAdapter().FromDirectionCosines(DesiredDirection));
    }

  itkBooleanMacro(UseImageDirection);
  itkGetConstMacro(UseImageDirection, bool);
  itkSetMacro(UseImageDirection, bool);

  itkGetConstReferenceMacro( PermuteOrder, PermuteOrderArrayType );

  itkGetConstReferenceMacro( FlipAxes, FlipAxesArrayType );

  void SetDesiredCoordinateOrientationToAxial ()
    {
   this->SetDesiredCoordinateOrientation (SpatialOrientation::ITK_COORDINATE_ORIENTATION_RAI);
    }
  void SetDesiredCoordinateOrientationToCoronal ()
    {
    this->SetDesiredCoordinateOrientation (SpatialOrientation::ITK_COORDINATE_ORIENTATION_RSA);
    }
  void SetDesiredCoordinateOrientationToSagittal ()
    {
    this->SetDesiredCoordinateOrientation (SpatialOrientation::ITK_COORDINATE_ORIENTATION_ASL);
    }

  virtual void GenerateOutputInformation();

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(InputConvertibleToOutput,
    (Concept::Convertible<InputImagePixelType, OutputImagePixelType>));
  itkConceptMacro(SameDimension,
    (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),itkGetStaticConstMacro(OutputImageDimension)>));
  itkConceptMacro(DimensionShouldBe3,
    (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),3>));

#endif

protected:
  OrientImageFilter();
  ~OrientImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  void GenerateInputRequestedRegion();

  void EnlargeOutputRequestedRegion(DataObject *itkNotUsed(output));

  void DeterminePermutationsAndFlips(const SpatialOrientation::ValidCoordinateOrientationFlags fixed_orient,
                                     const SpatialOrientation::ValidCoordinateOrientationFlags moving_orient);
  bool NeedToPermute();
  bool NeedToFlip();


  void GenerateData();


private:
  OrientImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  std::string GetMajorAxisFromPatientRelativeDirectionCosine(double x, double y, double z);

  CoordinateOrientationCode m_GivenCoordinateOrientation;
  CoordinateOrientationCode m_DesiredCoordinateOrientation;
  bool                      m_UseImageDirection;

  PermuteOrderArrayType     m_PermuteOrder;
  FlipAxesArrayType         m_FlipAxes;
  
  std::map<std::string,CoordinateOrientationCode> m_StringToCode;
  std::map<CoordinateOrientationCode,std::string> m_CodeToString;

}; // end of class

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkOrientImageFilter.txx"
#endif

#endif