cmtkEntropyMinimizationIntensityCorrectionFunctional.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: 2464 $
//
//  $LastChangedDate: 2010-10-19 09:54:33 -0700 (Tue, 19 Oct 2010) $
//
//  $LastChangedBy: torsten_at_home $
//
*/

#ifndef __cmtkEntropyMinimizationIntensityCorrectionFunctional_h_included_
#define __cmtkEntropyMinimizationIntensityCorrectionFunctional_h_included_

#include <cmtkconfig.h>

#include <Segmentation/cmtkEntropyMinimizationIntensityCorrectionFunctionalBase.h>

#include <Base/cmtkPolynomial.h>
#include <Base/cmtkUniformVolume.h>
#include <Base/cmtkDataGrid.h>

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

namespace
cmtk
{

template<unsigned int NOrderAdd,unsigned int NOrderMul>
class EntropyMinimizationIntensityCorrectionFunctional :
  public EntropyMinimizationIntensityCorrectionFunctionalBase
{
public:
  typedef EntropyMinimizationIntensityCorrectionFunctional<NOrderAdd,NOrderMul> Self;
  
  typedef SmartPointer<Self> SmartPtr;

  typedef EntropyMinimizationIntensityCorrectionFunctionalBase Superclass;

  typedef Polynomial<NOrderAdd,Types::Coordinate> PolynomialTypeAdd;

  typedef Polynomial<NOrderMul,Types::Coordinate> PolynomialTypeMul;

  EntropyMinimizationIntensityCorrectionFunctional() 
  {
    this->m_ParameterVector.SetDim( this->ParamVectorDim() );
    this->m_ParameterVector.SetAll( 0.0 );

    ThreadPool& threadPool = ThreadPool::GetGlobalThreadPool();
    this->m_NumberOfThreads = threadPool.GetNumberOfThreads();
    this->m_MonomialsPerThread = std::max( (int)PolynomialTypeAdd::NumberOfMonomials, (int)PolynomialTypeMul::NumberOfMonomials );
    this->m_MonomialsVec = Memory::AllocateArray<Types::Coordinate>( this->m_NumberOfThreads * this->m_MonomialsPerThread  );
  }

  virtual ~EntropyMinimizationIntensityCorrectionFunctional() 
  {
    Memory::DeleteArray( this->m_MonomialsVec );
  }

  static const size_t m_NumberOfParameters = PolynomialTypeAdd::NumberOfMonomials + PolynomialTypeMul::NumberOfMonomials;

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

#pragma GCC diagnostic ignored "-Wtype-limits"
  virtual Types::Coordinate GetParamStep( const size_t idx, const Types::Coordinate mmStep = 1 ) const 
  {
    if ( idx < PolynomialTypeAdd::NumberOfMonomials )
      return (this->m_InputImageRange / 256) * this->m_StepSizeAdd[idx] * mmStep;
    else
      return (this->m_InputImageRange / 256) * this->m_StepSizeMul[idx-PolynomialTypeAdd::NumberOfMonomials] * mmStep;
  }

  virtual size_t GetNumberOfMonomialsAdd() const 
  {
    return PolynomialTypeAdd::NumberOfMonomials;
  }

  virtual size_t GetNumberOfMonomialsMul() const 
  {
    return PolynomialTypeMul::NumberOfMonomials;
  }

  virtual void SetParamVector( CoordinateVector& v )
  {
    this->m_ParameterVector = v;
    for ( int i = 0; i < PolynomialTypeAdd::NumberOfMonomials; ++i )
      this->m_CoefficientsAdd[i] = v[i] * this->m_MulCorrectionAdd[i];
    
    size_t ofs = PolynomialTypeAdd::NumberOfMonomials;
    for ( int i = 0; i < PolynomialTypeMul::NumberOfMonomials; ++i, ++ofs )
      this->m_CoefficientsMul[i] = v[ofs] * this->m_MulCorrectionMul[i];
  }

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

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

protected:
  CoordinateVector m_ParameterVector;

  Types::Coordinate m_StepSizeAdd[1+PolynomialTypeAdd::NumberOfMonomials];
  
  Types::Coordinate m_StepSizeMul[1+PolynomialTypeMul::NumberOfMonomials];

  Types::Coordinate m_CoefficientsAdd[1+PolynomialTypeAdd::NumberOfMonomials];
  
  Types::Coordinate m_CoefficientsMul[1+PolynomialTypeMul::NumberOfMonomials];

  Types::Coordinate m_AddCorrectionAdd[1+PolynomialTypeAdd::NumberOfMonomials];

  Types::Coordinate m_MulCorrectionAdd[1+PolynomialTypeAdd::NumberOfMonomials];

  Types::Coordinate m_AddCorrectionMul[1+PolynomialTypeMul::NumberOfMonomials];

  Types::Coordinate m_MulCorrectionMul[1+PolynomialTypeMul::NumberOfMonomials];

private:
  size_t m_NumberOfThreads;

  size_t m_MonomialsPerThread;

  Types::Coordinate* m_MonomialsVec;

  virtual void UpdateCorrectionFactors();

  virtual void UpdateBiasFields( const bool foregroundOnly = true );

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

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

  virtual void UpdateBiasFieldAdd( const bool foregroundOnly = true );

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

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

  virtual void UpdateBiasFieldMul( const bool foregroundOnly = true );

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

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

template<unsigned int NDegreeMul>
EntropyMinimizationIntensityCorrectionFunctionalBase::SmartPtr
CreateEntropyMinimizationIntensityCorrectionFunctional
( const unsigned int polynomialDegreeAdd );

EntropyMinimizationIntensityCorrectionFunctionalBase::SmartPtr
CreateEntropyMinimizationIntensityCorrectionFunctional
( const unsigned int polynomialDegreeAdd, const unsigned int polynomialDegreeMul );

EntropyMinimizationIntensityCorrectionFunctionalBase::SmartPtr
CreateEntropyMinimizationIntensityCorrectionFunctional
( const unsigned int polynomialDegreeAdd, const unsigned int polynomialDegreeMul,
  EntropyMinimizationIntensityCorrectionFunctionalBase::SmartPtr oldFunctional );


} // namespace cmtk

#include "cmtkEntropyMinimizationIntensityCorrectionFunctional.txx"

#endif // #ifndef __cmtkEntropyMinimizationIntensityCorrectionFunctional_h_included_