cmtkSplineWarpMultiChannelRegistrationFunctional.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2010 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: 2398 $
//
//  $LastChangedDate: 2010-10-05 14:54:37 -0700 (Tue, 05 Oct 2010) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkSplineWarpMultiChannelRegistrationFunctional_h_included_
#define __cmtkSplineWarpMultiChannelRegistrationFunctional_h_included_

#include <cmtkconfig.h>

#include <Registration/cmtkMultiChannelRMIRegistrationFunctional.h>
#include <Registration/cmtkTemplateMultiChannelRegistrationFunctional.h>
#include <Registration/cmtkAffineMultiChannelRegistrationFunctional.h>

#include <Base/cmtkSplineWarpXform.h>

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

#include <list>

namespace
cmtk
{


template<class MetricFunctionalClass> 
class SplineWarpMultiChannelIntensityCorrectionRegistrationFunctional;

template<class TMetricFunctional = MultiChannelRMIRegistrationFunctional<> >
class SplineWarpMultiChannelRegistrationFunctional :
  public TemplateMultiChannelRegistrationFunctional<SplineWarpXform, TMetricFunctional >
{
public:
  typedef SplineWarpMultiChannelRegistrationFunctional Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef TemplateMultiChannelRegistrationFunctional<SplineWarpXform, TMetricFunctional > Superclass;

  typedef typename Superclass::MetricData MetricData;

  SplineWarpMultiChannelRegistrationFunctional();

  template<class TAffineMetricFunctional>
  SplineWarpMultiChannelRegistrationFunctional
  ( AffineMultiChannelRegistrationFunctional<TAffineMetricFunctional>& affineFunctional );

  virtual void SetInitialAffineTransformation( const AffineXform& initialAffine )
  {
    this->m_InitialAffineTransformation = initialAffine;
  }

  void SetAdaptiveFixEntropyThreshold( const bool flag )
  {
    this->m_AdaptiveFixEntropyThreshold = flag;
  }

  void SetAdaptiveFixThreshFactor( const float factor )
  {
    this->m_AdaptiveFixThreshFactor = factor;
  }

  void ClearFixedCoordinateDimensions()
  {
    this->m_FixedCoordinateDimensions.clear();
  }

  void AddFixedCoordinateDimension( const int dim )
  {
    this->m_FixedCoordinateDimensions.push_back( dim );
  }

  void SetJacobianConstraintWeight( const float weight )
  {
    this->m_JacobianConstraintWeight = weight;
  }

  virtual void InitTransformation( const Vector3D& domain, const Types::Coordinate gridSpacing, const bool exact );

  virtual void RefineTransformation();

  virtual void ClearAllChannels()
  {
    this->ClearReformattedFloatingChannels();
    Superclass::ClearAllChannels();
  }

  virtual typename Self::ReturnType Evaluate();
  
  virtual typename Self::ReturnType EvaluateWithGradient( CoordinateVector& v, CoordinateVector& g, const Types::Coordinate step = 1 );

protected:
  virtual void NewReferenceChannelGeometry() 
  {
    this->UpdateTransformationData();
  }

private:
  AffineXform m_InitialAffineTransformation;

  virtual void UpdateTransformationData();

  std::vector< std::vector<float> > m_ReformattedFloatingChannels;
  
  virtual void AllocateReformattedFloatingChannels();

  virtual void ClearReformattedFloatingChannels();

  typename Self::ReturnType EvaluateIncremental( const SplineWarpXform* warp, MetricData& metricData, const DataGrid::RegionType& region );

  virtual void ContinueMetricStoreReformatted( MetricData& metricData, const size_t rindex, const Vector3D& fvector );

  virtual void BacktraceMetric( MetricData& metricData, const DataGrid::RegionType& voi );

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

  std::vector<DataGrid::RegionType> m_VolumeOfInfluenceVector;

  bool m_AdaptiveFixEntropyThreshold;

  float m_AdaptiveFixThreshFactor;

  std::list<int> m_FixedCoordinateDimensions;

  float m_JacobianConstraintWeight;

  virtual void UpdateTransformationFixedControlPoints();

  bool m_UpdateTransformationFixedControlPointsRequired;

  const size_t m_NumberOfThreads;

  static void EvaluateThreadFunction( void* args, const size_t taskIdx, const size_t taskCnt, const size_t threadIdx, const size_t );

  MutexLock m_MetricDataMutex;

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

  class EvaluateGradientThreadParameters : 
    public ThreadParameters<Self>
  {
  public:
    Types::Coordinate m_Step;

    Types::Coordinate* m_Gradient;

    const CoordinateVector* m_ParameterVector;

    typename Self::ReturnType m_MetricBaseValue;
  };

  static void EvaluateWithGradientThreadFunction( void* args, const size_t taskIdx, const size_t taskCnt, const size_t threadIdx, const size_t );

  template<class MetricFunctionalClass> friend class SplineWarpMultiChannelIntensityCorrectionRegistrationFunctional;
};


} // namespace cmtk

#include "cmtkSplineWarpMultiChannelRegistrationFunctional.txx"
#include "cmtkSplineWarpMultiChannelRegistrationFunctionalThreadFunctions.txx"

#endif // #ifndef __cmtkSplineWarpMultiChannelRegistrationFunctional_h_included_