elxTransformixFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef elxTransformixFilter_h
#define elxTransformixFilter_h
 
#include "itkImageSource.h"
 
#include "elxTransformixMain.h"
#include "elxParameterObject.h"
#include "elxPixelType.h"
 
namespace elastix
{
 
template< typename TMovingImage >
class ELASTIXLIB_API TransformixFilter : public itk::ImageSource< TMovingImage >
{
public:
 
  typedef TransformixFilter               Self;
  typedef itk::ImageSource< TMovingImage > Superclass;
  typedef itk::SmartPointer< Self >       Pointer;
  typedef itk::SmartPointer< const Self > ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( TransformixFilter, itk::ImageSource );
 
  typedef elastix::TransformixMain             TransformixMainType;
  typedef TransformixMainType::Pointer         TransformixMainPointer;
  typedef TransformixMainType::ArgumentMapType ArgumentMapType;
  typedef ArgumentMapType::value_type          ArgumentMapEntryType;
 
  typedef itk::ProcessObject::DataObjectPointer           DataObjectPointer;
  typedef itk::ProcessObject::DataObjectIdentifierType    DataObjectIdentifierType;
  typedef TransformixMainType::DataObjectContainerType    DataObjectContainerType;
  typedef TransformixMainType::DataObjectContainerPointer DataObjectContainerPointer;
 
  typedef ParameterObject                               ParameterObjectType;
  typedef ParameterObjectType::ParameterMapVectorType   ParameterMapVectorType;
  typedef ParameterObjectType::ParameterMapType         ParameterMapType;
  typedef ParameterObjectType::ParameterValueVectorType ParameterValueVectorType;
  typedef typename ParameterObjectType::Pointer         ParameterObjectPointer;
  typedef typename ParameterObjectType::ConstPointer    ParameterObjectConstPointer;
 
  typedef typename Superclass::OutputImageType OutputImageType;
  typedef typename itk::Image< itk::Vector< float, TMovingImage::ImageDimension >,
                         TMovingImage::ImageDimension > OutputDeformationFieldType;
 
  typedef typename TMovingImage::Pointer      InputImagePointer;
  typedef typename TMovingImage::ConstPointer InputImageConstPointer;
 
  itkStaticConstMacro( MovingImageDimension, unsigned int, TMovingImage::ImageDimension );
 
  virtual void SetMovingImage( TMovingImage * inputImage );
  InputImageConstPointer GetMovingImage( void );
  virtual void RemoveMovingImage( void );
 
  itkSetMacro( FixedPointSetFileName, std::string );
  itkGetMacro( FixedPointSetFileName, std::string );
  virtual void RemoveFixedPointSetFileName() { this->SetFixedPointSetFileName( "" ); }
 
  itkSetMacro( ComputeSpatialJacobian, bool );
  itkGetConstMacro( ComputeSpatialJacobian, bool );
  itkBooleanMacro( ComputeSpatialJacobian );
 
  itkSetMacro( ComputeDeterminantOfSpatialJacobian, bool );
  itkGetConstMacro( ComputeDeterminantOfSpatialJacobian, bool );
  itkBooleanMacro( ComputeDeterminantOfSpatialJacobian );
 
  itkSetMacro( ComputeDeformationField, bool );
  itkGetConstMacro( ComputeDeformationField, bool );
  itkBooleanMacro( ComputeDeformationField );
 
  virtual void SetTransformParameterObject( ParameterObjectPointer transformParameterObject );
 
  ParameterObjectType* GetTransformParameterObject( void );
 
  const ParameterObjectType* GetTransformParameterObject( void ) const;
 
  OutputDeformationFieldType* GetOutputDeformationField( void );
 
  const OutputDeformationFieldType* GetOutputDeformationField( void ) const;
 
  itkSetMacro( OutputDirectory, std::string );
  itkGetConstMacro( OutputDirectory, std::string );
  virtual void RemoveOutputDirectory() { this->SetOutputDirectory( "" ); }
 
  virtual void SetLogFileName( std::string logFileName );
 
  itkGetConstMacro( LogFileName, std::string );
  virtual void RemoveLogFileName( void );
 
  itkSetMacro( LogToConsole, bool );
  itkGetConstMacro( LogToConsole, bool );
  itkBooleanMacro( LogToConsole );
 
  itkSetMacro( LogToFile, bool );
  itkGetConstMacro( LogToFile, bool );
  itkBooleanMacro( LogToFile );
 
  virtual DataObjectPointer MakeOutput( const DataObjectIdentifierType & key ) override;
 
  virtual void GenerateOutputInformation( void ) override;
 
protected:
 
  TransformixFilter( void );
 
  virtual void GenerateData( void ) override;
 
private:
 
  TransformixFilter( const Self & ); // purposely not implemented
  void operator=( const Self & );    // purposely not implemented
 
  static bool IsEmpty( const InputImagePointer inputImage );
 
  using itk::ProcessObject::SetInput;
  using itk::ProcessObject::GetInput;
  using itk::ProcessObject::RemoveInput;
 
  std::string m_FixedPointSetFileName;
  bool        m_ComputeSpatialJacobian;
  bool        m_ComputeDeterminantOfSpatialJacobian;
  bool        m_ComputeDeformationField;
 
  std::string m_OutputDirectory;
  std::string m_LogFileName;
 
  bool m_LogToConsole;
  bool m_LogToFile;
 
};
 
} // namespace elx
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "elxTransformixFilter.hxx"
#endif
 
#endif // elxTransformixFilter_h