itkCompositeValleyFunction.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkCompositeValleyFunction_h
#define __itkCompositeValleyFunction_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 ITK_EXPORT 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;