itkAffineGeometryFrame.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkAffineGeometryFrame.h,v $
  Language:  C++
  Date:      $Date: 2009-01-28 20:10:26 $
  Version:   $Revision: 1.8 $

  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 __itkAffineGeometryFrame_h
#define __itkAffineGeometryFrame_h

#include "itkObject.h"
#include "itkMacro.h"
#include "itkScalableAffineTransform.h"
#include "itkBoundingBox.h"

namespace itk 
{

template <class TScalarType = double, unsigned int NDimensions = 3>
class AffineGeometryFrame : public itk::Object
{
public:
  typedef AffineGeometryFrame       Self;
  typedef itk::Object               Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  typedef ScalableAffineTransform<TScalarType, NDimensions>    TransformType;
  typedef BoundingBox<unsigned long, NDimensions, TScalarType> BoundingBoxType;
  typedef typename BoundingBoxType::BoundsArrayType            BoundsArrayType;
  typedef typename BoundingBoxType::Pointer                 BoundingBoxPointer;

  itkNewMacro(Self);

  itkTypeMacro(AffineGeometryFrame, Object);

  itkGetConstObjectMacro(BoundingBox, BoundingBoxType);

  const BoundsArrayType GetBounds() const
    {
    assert(m_BoundingBox.IsNotNull());
    return m_BoundingBox->GetBounds();
    }

  virtual void SetBounds(const BoundsArrayType& bounds);

  TScalarType GetExtent(unsigned int direction) const
    {
    assert(direction<NDimensions);
    assert(m_BoundingBox.IsNotNull());
    BoundsArrayType bounds = m_BoundingBox->GetBounds();
    return bounds[direction*2+1]-bounds[direction*2];
    }

  itkGetConstObjectMacro(IndexToObjectTransform, TransformType);
  itkGetObjectMacro(IndexToObjectTransform, TransformType);
  itkSetObjectMacro(IndexToObjectTransform, TransformType);

  itkGetConstObjectMacro(ObjectToNodeTransform, TransformType);
  itkGetObjectMacro(ObjectToNodeTransform, TransformType);
  itkSetObjectMacro(ObjectToNodeTransform, TransformType);

  itkGetConstObjectMacro(IndexToWorldTransform, TransformType);
  itkGetObjectMacro(IndexToWorldTransform, TransformType);
  itkSetObjectMacro(IndexToWorldTransform, TransformType);


  itkGetConstObjectMacro(IndexToNodeTransform, TransformType);

  virtual void Initialize();

  virtual Pointer Clone() const;

protected:

  AffineGeometryFrame();
  virtual ~AffineGeometryFrame();

  virtual void InitializeGeometry(Self * newGeometry) const;
  void SetBoundsArray(const BoundsArrayType& bounds, 
                      BoundingBoxPointer& boundingBox);
  mutable BoundingBoxPointer m_BoundingBox;

  typename TransformType::Pointer m_IndexToObjectTransform;
  typename TransformType::Pointer m_ObjectToNodeTransform;
  typename TransformType::Pointer m_IndexToNodeTransform;
  typename TransformType::Pointer m_IndexToWorldTransform;

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

};

} // namespace itk


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


#endif /* __itkAffineGeometryFrame_h */