itkCompositeValleyFunction.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCompositeValleyFunction.h,v $
  Language:  C++
  Date:      $Date: 2007-03-22 14:29:13 $
  Version:   $Revision: 1.10 $

  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