cmtkEntropyMinimizationIntensityCorrectionFunctionalBase.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 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 __cmtkEntropyMinimizationIntensityCorrectionFunctionalBase_h_included_
#define __cmtkEntropyMinimizationIntensityCorrectionFunctionalBase_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkFunctional.h>
#include <System/cmtkSmartPtr.h>
#include <System/cmtkThreads.h>

#include <Base/cmtkUniformVolume.h>
#include <Base/cmtkDataGrid.h>
#include <Base/cmtkHistogram.h>
#include <Base/cmtkLogHistogram.h>
#include <Base/cmtkTemplateArray.h>

#include <vector>

namespace
cmtk
{


class EntropyMinimizationIntensityCorrectionFunctionalBase
  : public Functional
{
public:
  typedef EntropyMinimizationIntensityCorrectionFunctionalBase Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef Functional Superclass;

  EntropyMinimizationIntensityCorrectionFunctionalBase() 
    : m_SamplingDensity( 1.0 ),
      m_NumberOfHistogramBins( 256 ),
      m_UseLogIntensities( false )
  {}

  virtual ~EntropyMinimizationIntensityCorrectionFunctionalBase() {}

  virtual size_t GetNumberOfMonomialsAdd() const = 0;

  virtual size_t GetNumberOfMonomialsMul() const = 0; 

  virtual void SetInputImage( UniformVolume::SmartConstPtr& inputImage );

  virtual void SetForegroundMask( const UniformVolume& foregroundMask );

  virtual void SetSamplingDensity( const float samplingDensity )
  {
    this->m_SamplingDensity = samplingDensity;
  }

  virtual void SetNumberOfHistogramBins( const size_t numberOfHistogramBins )
  {
    this->m_NumberOfHistogramBins = numberOfHistogramBins;
  }

  void SetUseLogIntensities( const bool flag )
  {
    this->m_UseLogIntensities = flag;
  }

  virtual UniformVolume::SmartPtr& GetOutputImage( const bool update = false )
  {
    if ( update )
      this->UpdateOutputImage( false /*foregroundOnly*/);
    
    return this->m_OutputImage;
  }

  virtual UniformVolume::SmartPtr& GetOutputImage( CoordinateVector& v, const bool foregroundOnly = false );
  
  virtual UniformVolume::SmartPtr GetBiasFieldAdd( const bool updateCompleteImage = false )
  {
    if ( updateCompleteImage )
      this->UpdateBiasFieldAdd( false /*foregroundOnly*/ );

    UniformVolume::SmartPtr biasField( this->m_OutputImage->CloneGrid() );
    biasField->SetData( this->m_BiasFieldAdd );
    return biasField;
  }

  virtual void SetBiasFieldAdd( const UniformVolume& biasFieldAdd )
  {
    biasFieldAdd.GetData()->BlockCopy( *(this->m_BiasFieldAdd), 0, 0, this->m_BiasFieldAdd->GetDataSize() );
  }

  virtual UniformVolume::SmartPtr GetBiasFieldMul( const bool updateCompleteImage = false )
  {
    if ( updateCompleteImage )
      this->UpdateBiasFieldMul( false /*foregroundOnly*/ );

    UniformVolume::SmartPtr biasField( this->m_OutputImage->CloneGrid() );
    biasField->SetData( this->m_BiasFieldMul );
    return biasField;
  }

  virtual void SetBiasFieldMul( const UniformVolume& biasFieldMul )
  {
    biasFieldMul.GetData()->BlockCopy( *(this->m_BiasFieldMul), 0, 0, this->m_BiasFieldMul->GetDataSize() );
  }

  virtual Self::ReturnType Evaluate()
  {
    return static_cast<Self::ReturnType>( -this->m_OutputImage->GetData()->GetEntropy( *this->m_EntropyHistogram ) );
  }

  virtual Self::ReturnType EvaluateAt( CoordinateVector& v );

#ifdef CMTK_BUILD_DEMO

  virtual void SnapshotAt( CoordinateVector& v );
#endif

protected:
  UniformVolume::SmartConstPtr m_InputImage;

  Types::DataItem m_InputImageRange;

  UniformVolume::SmartPtr m_OutputImage;

  typedef Histogram<unsigned int> HistogramType;

  typedef LogHistogram<unsigned int> LogHistogramType;

  HistogramType::SmartPtr m_EntropyHistogram;

  std::vector<bool> m_ForegroundMask;

  virtual void UpdateCorrectionFactors() = 0;

  virtual void UpdateOutputImage( const bool foregroundOnly = true );

  FloatArray::SmartPtr m_BiasFieldAdd;

  FloatArray::SmartPtr m_BiasFieldMul;

  virtual void UpdateBiasFields( const bool foregroundOnly = true ) = 0;

  virtual void UpdateBiasFieldAdd( const bool foregroundOnly = true ) = 0;

  virtual void UpdateBiasFieldMul( const bool foregroundOnly = true ) = 0;

  size_t m_NumberOfPixels;

protected:  
  float m_SamplingDensity;

  size_t m_NumberOfHistogramBins;

  bool m_UseLogIntensities;

private:  
  class UpdateOutputImageThreadParameters :
    public ThreadParameters<Self>
  {
  public:
    bool m_ForegroundOnly;
  };

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


} // namespace cmtk

#endif // #ifndef __cmtkEntropyMinimizationIntensityCorrectionFunctionalBase_h_included_