cmtkWarpXform.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2010 Torsten Rohlfing
//
//  Copyright 2004-2011 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit is distributed in the hope that it
//  will be useful, but WITHOUT ANY WARRANTY; without even the implied
//  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2752 $
//
//  $LastChangedDate: 2011-01-17 11:33:31 -0800 (Mon, 17 Jan 2011) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkWarpXform_h_included_
#define __cmtkWarpXform_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkXform.h>

#include <Base/cmtkMacros.h>
#include <Base/cmtkVector.h>
#include <Base/cmtkFixedVector.h>

#include <Base/cmtkVolume.h>
#include <Base/cmtkUniformVolume.h>

#include <Base/cmtkAffineXform.h>
#include <Base/cmtkBitVector.h>

#include <Base/cmtkControlPoint.h>
#include <Base/cmtkMatchedLandmarkList.h>

#include <System/cmtkSmartPtr.h>

namespace
cmtk
{


class WarpXform : 
  public Xform 
{
public:
  typedef WarpXform Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef SmartConstPointer<Self> SmartConstPtr;

  typedef FixedVector<3,int> IndexType;
  
  Self::IndexType m_Dims;

  FixedVector<3,Types::Coordinate> Domain;

  Types::Coordinate Spacing[3];

  Self::SpaceVectorType m_Offset;

  virtual Types::Coordinate GetGlobalScaling() const
  { return this->GlobalScaling; }

  cmtkGetSetMacro(AffineXform::SmartPtr,InitialAffineXform);

  void ReplaceInitialAffine( const AffineXform* newAffineXform = NULL );

  void ConcatAffine( const AffineXform* affineXform );

  size_t GetNumberOfControlPoints() const
  {
    return this->NumberOfControlPoints;
  }

protected:
  size_t NumberOfControlPoints;

  Types::Coordinate InverseSpacing[3];

  cmtkGetSetMacro(unsigned int,IgnoreEdge);

  cmtkGetSetMacroDefault(bool,FastMode,true);

  Types::Coordinate GlobalScaling;

  Types::Coordinate InverseAffineScaling[3];

  int nextI;

  int nextJ;

  int nextIJ;

  int nextK;

  int nextIK;

  int nextJK;

  int nextIJK;

public:
  WarpXform () : 
    m_InitialAffineXform( NULL ), 
    m_ActiveFlags( NULL )
  { 
    this->m_IgnoreEdge = 0; 
    this->m_FastMode = false; 
    this->m_Dims[0] = this->m_Dims[1] = this->m_Dims[2] = 0;
    this->InverseSpacing[0] = this->InverseSpacing[1] = this->InverseSpacing[2] = 0.0;
  }

  virtual ~WarpXform () {}

  virtual void InitGrid( const FixedVector<3,Types::Coordinate>& domain, const Self::IndexType& dims );

  virtual bool InDomain( const Self::SpaceVectorType& v ) const 
  {
    return 
      ( v[0] >= 0 ) && ( v[0] <= Domain[0] ) &&
      ( v[1] >= 0 ) && ( v[1] <= Domain[1] ) &&
      ( v[2] >= 0 ) && ( v[2] <= Domain[2] );
  }
  
  virtual void Update( const bool exactDelta = false );

  virtual void Refine() {}

  virtual Self::SpaceVectorType Apply ( const Self::SpaceVectorType& v ) const 
  {
    Self::SpaceVectorType w(v);
    this->ApplyInPlace( w );
    return w;
  }
  
  virtual void GetDerivativeLandmarksMSD( double& lowerMSD, double& upperMSD, const MatchedLandmarkList* ll, const unsigned int idx, const Types::Coordinate step );

  virtual Types::Coordinate GetInverseConsistencyError( const Self* inverse, const UniformVolume* volume, const UniformVolume::RegionType* voi = NULL ) const;
  
  virtual void GetDerivativeInverseConsistencyError
  ( double& lower, double& upper, const Self* inverse, const UniformVolume* volume, const UniformVolume::RegionType* voi, 
    const unsigned int idx, const Types::Coordinate step );
  
  virtual void GetOriginalControlPointPosition( Self::SpaceVectorType& cp, const Types::Coordinate x, const Types::Coordinate y, const Types::Coordinate z) const 
  { 
    cp[0] = this->m_Offset[0] + x*this->Spacing[0];
    cp[1] = this->m_Offset[1] + y*this->Spacing[1];
    cp[2] = this->m_Offset[2] + z*this->Spacing[2];
  }
  
  virtual void GetOriginalControlPointPositionByOffset( Self::SpaceVectorType& v, const size_t offset ) const 
  {
    this->GetOriginalControlPointPosition( v, offset % this->m_Dims[0], (offset % (this->m_Dims[0]*this->m_Dims[1])) / this->m_Dims[0], offset / (this->m_Dims[0]*this->m_Dims[1]) ); 
  }

  virtual void GetShiftedControlPointPosition( Self::SpaceVectorType& v, const int x, const int y, const int z ) const 
  { 
    this->GetShiftedControlPointPositionByOffset( v, x + this->m_Dims[0] * (y + this->m_Dims[1] * z ) );
  }

  virtual void GetShiftedControlPointPositionByOffset( Self::SpaceVectorType& v, const size_t offset ) const 
  { 
    for ( size_t i = 0; i<3; ++i )
      v[i] = this->m_Parameters[offset*3+i];
  }

  virtual void SetShiftedControlPointPositionByOffset( const Self::SpaceVectorType& v, const int x, const int y, const int z ) const 
  { 
    this->SetShiftedControlPointPositionByOffset( v, x + this->m_Dims[0] * (y + this->m_Dims[1] * z ) );
  }

  virtual void SetShiftedControlPointPositionByOffset( const Self::SpaceVectorType& v, const size_t offset ) const 
  { 
    for ( int idx = 0; idx < 3; ++idx )
      this->m_Parameters[idx+offset*3] = v[idx];
  }

  virtual Types::Coordinate GetParamStep( const size_t, const Self::SpaceVectorType& volSize, const Types::Coordinate mmStep = 1 ) const;

  void DeleteParameterActiveFlags();

  void SetParametersActive();

  void SetParametersActive( const UniformVolume::RegionType& roi );
  
  void SetParametersActive( const int axis, const bool active = true );

  void SetParameterActive( const size_t index, const bool active = true );

  void SetParameterInactive( const size_t index );

  void SetParametersActive( const char* axes );

  int GetParameterActive( const size_t index ) const;

private:
  cmtkGetSetMacro(BitVector::SmartPtr,ActiveFlags);

  friend class SplineWarpXformUniformVolume;
};


} // namespace cmtk

#endif // #ifndef __cmtkWarpXform_h_included_