itkCompositeValleyFunction.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCompositeValleyFunction.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:29:37 $
  Version:   $Revision: 1.9 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkCompositeValleyFunction_h
#define __itkCompositeValleyFunction_h

#include "itkArray.h"
#include "itkCacheableScalarFunction.h"
#include <vector>

namespace itk {

class TargetClass
{
public:
  TargetClass(double mean, double sigma) 
  { 
    m_Mean = mean ;
    m_Sigma = sigma ;
  }
  
  void SetMean(double mean) { m_Mean = mean ; }  
  double GetMean() { return m_Mean ; } 
  
  void SetSigma(double sigma) { m_Sigma = sigma ; }
  double GetSigma() { return m_Sigma ; }
    
private:
  double m_Mean ;
  double m_Sigma ;
} ; // end of class 

class CompositeValleyFunction : public CacheableScalarFunction
{
public:

  typedef CacheableScalarFunction Superclass;
  
  typedef  Superclass::MeasureType          MeasureType;
  typedef  Superclass::MeasureArrayType     MeasureArrayType;

  CompositeValleyFunction( const MeasureArrayType & classMeans, 
                           const MeasureArrayType & classSigmas );

  virtual ~CompositeValleyFunction() {}

  double GetUpperBound() { return m_UpperBound ; }

  double GetLowerBound() { return m_LowerBound ; }

  MeasureType operator() (MeasureType x)
  {
    if (x > m_UpperBound || x < m_LowerBound) { return 1; }

    if (!this->IsCacheAvailable()) 
      { return this->Evaluate(x); } 
    else 
      { return GetCachedValue(x); }
  }

  inline MeasureType Evaluate(MeasureType x) 
  {
    MeasureType res = 1;
    
    for (unsigned int k = 0 ; k < m_Targets.size() ; k++)
      {
      res *= valley( ( x - m_Targets[k].GetMean() ) /
                     m_Targets[k].GetSigma() );
      }
    
    return res;
  }  

  inline MeasureType valley(MeasureType d) 
  { return 1 - 1 / (1+d*d/3); }

protected:
  void AddNewClass(double mean, double sigma)
  {
    TargetClass aClass(mean, sigma) ;
    m_Targets.push_back(aClass) ;
  }

  void Initialize() ;

private:
  std::vector<TargetClass> m_Targets;  

  double m_UpperBound ;

  double m_LowerBound ;

} ; // end of class

} // end of namespace itk
#endif

---