cmtkImagePairNonrigidRegistrationFunctional.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2010 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: 2660 $
//
//  $LastChangedDate: 2010-12-14 12:35:50 -0800 (Tue, 14 Dec 2010) $
//
//  $LastChangedBy: torsten_at_home $
//
*/

#ifndef __cmtkImagePairNonrigidRegistrationFunctional_h_included_
#define __cmtkImagePairNonrigidRegistrationFunctional_h_included_

#include <cmtkconfig.h>

#include <Registration/cmtkImagePairRegistrationFunctional.h>
#include <Registration/cmtkImagePairSimilarityMeasure.h>

#include <System/cmtkThreads.h>
#include <System/cmtkThreadPool.h>

#include <Base/cmtkSplineWarpXform.h>
#include <Base/cmtkJointHistogram.h>

#ifdef HAVE_IEEEFP_H
#  include <ieeefp.h>
#endif

#include <math.h>

namespace
cmtk
{


class ImagePairNonrigidRegistrationFunctional : 
  public ImagePairRegistrationFunctional 
{
public:
  typedef ImagePairNonrigidRegistrationFunctional Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef ImagePairRegistrationFunctional Superclass;

  virtual ~ImagePairNonrigidRegistrationFunctional ();

  cmtkGetSetMacroDefault(bool,AdaptiveFixParameters,true);

  cmtkGetSetMacro(double,AdaptiveFixThreshFactor);

  cmtkGetSetMacroString(ActiveCoordinates);

  cmtkGetSetMacroDefault(double,JacobianConstraintWeight,0);

  cmtkGetSetMacroDefault(double,GridEnergyWeight,0);

  virtual void SetWarpXform( SplineWarpXform::SmartPtr& warp ) = 0;

  void SetInverseTransformation( SplineWarpXform::SmartPtr& inverseTransformation ) 
  {
    this->m_InverseTransformation = inverseTransformation;
  }

  void SetInverseConsistencyWeight( const double inverseConsistencyWeight ) 
  {
    this->m_InverseConsistencyWeight = inverseConsistencyWeight;
  }

  virtual Types::Coordinate GetParamStep( const size_t idx, const Types::Coordinate mmStep = 1 ) const 
  {
    return this->m_Warp->GetParamStep( idx, this->m_FloatingSize, mmStep );
  }

  virtual size_t ParamVectorDim() const 
  {
    return this->m_Warp->ParamVectorDim();
  }

  virtual size_t VariableParamVectorDim() const 
  {
    return this->m_Warp->VariableParamVectorDim();
  }

  virtual void GetParamVector ( CoordinateVector& v ) 
  {
    this->m_Warp->GetParamVector( v );
  }

  static ImagePairNonrigidRegistrationFunctional* Create
  ( const int metric, UniformVolume::SmartPtr& refVolume, UniformVolume::SmartPtr& fltVolume, const Interpolators::InterpolationEnum interpolation );
  
protected:
  ImagePairNonrigidRegistrationFunctional( UniformVolume::SmartPtr& reference, UniformVolume::SmartPtr& floating );

  std::vector<SplineWarpXform::SmartPtr> m_ThreadWarp;

  Vector3D **m_ThreadVectorCache;

  size_t m_NumberOfThreads;

  size_t m_NumberOfTasks;

  Types::DataItem *m_WarpedVolume;

  DataGrid::IndexType::ValueType m_DimsX, m_DimsY, m_DimsZ;
  
  DataGrid::IndexType::ValueType m_FltDimsX, m_FltDimsY;

  SplineWarpXform::SmartPtr m_Warp;

  SplineWarpXform::SmartPtr m_InverseTransformation;

  double m_InverseConsistencyWeight;

  Self::ReturnType WeightedTotal( const Self::ReturnType metric, const SplineWarpXform& warp ) const 
  {
    double result = metric;
    if ( this->m_JacobianConstraintWeight > 0 ) 
      {
      result -= this->m_JacobianConstraintWeight * warp.GetJacobianConstraint();
      } 
    
    if ( this->m_GridEnergyWeight > 0 ) 
      {
      result -= this->m_GridEnergyWeight * warp.GetGridEnergy();
      }
    
    if ( !finite( result ) ) 
      return -FLT_MAX;
    
    if ( this->m_MatchedLandmarkList ) 
      {
      result -= this->m_LandmarkErrorWeight * warp.GetLandmarksMSD( this->m_MatchedLandmarkList );
      }

    if ( this->m_InverseTransformation ) 
      {
      result -= this->m_InverseConsistencyWeight * warp.GetInverseConsistencyError( this->m_InverseTransformation, this->m_ReferenceGrid );
      }
    
    return static_cast<Self::ReturnType>( result );
  }
  
  void WeightedDerivative( double& lower, double& upper, SplineWarpXform& warp, const int param, const Types::Coordinate step ) const;

  cmtkGetSetMacroDefault(bool,Regularize,false);

  size_t Dim;

  std::vector<Types::Coordinate> m_StepScaleVector;

  DataGrid::RegionType *VolumeOfInfluence;

  Vector3D ReferenceFrom;

  Vector3D ReferenceTo;

  friend class SmartPointer<Self>;
};


} // namespace cmtk

#endif // __cmtkImagePairNonrigidRegistrationFunctional_h_included_