freESCMAMutation.h

Go to the documentation of this file.

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

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freESCMAMutation.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/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 __freESCMAMutation_h
#define __freESCMAMutation_h

#include "freESMutationBase.h"
#include "freESParentSelectorBase.h"
#include "freESRecombinatorBase.h"

#include "itkNormalVariateGenerator.h"

#include "vnl/vnl_vector.h" 
#include "vnl/vnl_matrix.h" 

namespace FREE
{
  namespace ES
  {

    template <class TIndividual>
    class ITK_EXPORT CMAMutation: 
      public MutationBase<TIndividual>
    {
    public:
      typedef CMAMutation<TIndividual>     Self ;
      typedef MutationBase<TIndividual>           Superclass;
      typedef itk::SmartPointer<Self>             Pointer;
      typedef itk::SmartPointer<const Self>       ConstPointer;

      itkNewMacro(Self);

      itkTypeMacro(CMAMutation, MutationBase);

      typedef typename Superclass::IndividualType   IndividualType;
      typedef typename IndividualType::Pointer      IndividualPointer;
      typedef typename Superclass::PopulationType   PopulationType;
      typedef typename PopulationType::Pointer      PopulationPointer;

      typedef vnl_matrix<double>  MatrixType;
      typedef vnl_vector<double>  VectorType;

      void RegisterStrategicPopulationParameters(PopulationType& population) const;
      void MutateStrategicPopulationParameters(PopulationType& population) const;

      double MutateValue(const double& value);

      void InitializeControlValues_Mean(const long& lN);
      
      void InitializeControlValues_Hansen(const long& lMu, const long& lN);

      itkSetMacro( Sigma, double );
      itkGetMacro( Sigma, double );

      itkGetMacro( Mu, long );

      itkSetMacro( Mu_eff, double );
      itkGetMacro( Mu_eff, double );

      itkSetMacro( Mu_cov, double );
      itkGetMacro( Mu_cov, double );

      itkSetMacro( C_c, double );
      itkGetMacro( C_c, double );

      itkSetMacro( C_cov, double );
      itkGetMacro( C_cov, double );

      itkSetMacro( C_sigma, double );
      itkGetMacro( C_sigma, double );

      itkSetMacro( D_sigma, double );
      itkGetMacro( D_sigma, double );

      itkGetConstReferenceMacro(CurMatrix,MatrixType);
      itkGetConstReferenceMacro(CurCentroid,VectorType);
      itkGetConstReferenceMacro(CurMatrixPath,VectorType);
      itkGetConstReferenceMacro(CurStepPath,VectorType);
      itkGetConstReferenceMacro(CurStepLength,double);

      typedef ParentSelectorBase<TIndividual>   SearchPointSelectorType;
      typedef typename SearchPointSelectorType::Pointer  SearchPointSelectorPointer;
      typedef RecombinatorBase<TIndividual>     CentroidCombinatorType;
      typedef typename CentroidCombinatorType::Pointer  CentroidCombinatorPointer;

      virtual void SetCentroidCombinator( CentroidCombinatorType * pCentroidCombinator );
      itkGetConstObjectMacro( CentroidCombinator, CentroidCombinatorType );
      itkGetObjectMacro( CentroidCombinator, CentroidCombinatorType );

      virtual void SetSearchPointSelector( SearchPointSelectorType * pSearchPointSelector );
      itkGetConstObjectMacro( SearchPointSelector, SearchPointSelectorType );
      itkGetObjectMacro( SearchPointSelector, SearchPointSelectorType );

            typedef itk::Statistics::NormalVariateGenerator VariateGeneratorType ;
      VariateGeneratorType& GetRandomGenerator() {return *(m_RandomGenerator.GetPointer());};

    protected:
      CMAMutation() ;

      double m_Sigma;

      double m_Mu_cov;

      double m_Mu_eff;

      double m_C_c;

      double m_C_cov;

      double m_C_sigma;

      double m_D_sigma;

      void MutateObjectivParameters(IndividualType* pIndividual, PopulationType* pPopulation) const;

      typedef typename PopulationType::StrategicParametersType PopulationStrategicParametersType;

      /*Extracts the strategic parameters of the population that belong to this
       * class and converts them into the member variables m_CovMatrix, m_CurCentroid,
       * m_CurPath, m_LastCentroid, m_LastPath.
       * \param parameters Parameters of the population that contain the information.
       */
      void ConvertStrategicPopulationParametersToMember(PopulationStrategicParametersType& parameters) const;
      /*Stores the member variables m_CovMatrix, m_CurCentroid, m_CurPath,
       * m_LastCentroid, m_LastPath in the strategic parameters of the population.
       * bevor storing the members the parameters belonging to the class will be reseted.
       * \param parameters Parameters where the information should be stored.
       */
      void ConvertMemberToStrategicPopulationParameters(PopulationStrategicParametersType& parameters) const;

      VectorType ComputeCentroid(PopulationType& rPopulation) const;
      VectorType ComputeMatrixPath(const VectorType& curMatrixPath, double curStepLength, const VectorType& curCentroid, const VectorType& nextCentroid) const;
      MatrixType ComputeMatrix(const MatrixType& curMatrix, const VectorType& nextMatrixPath, double curStepLength, const VectorType& curCentroid, const PopulationType& population) const;
      VectorType ComputeStepPath(const VectorType& curStepPath,const MatrixType& curMatrix, double curStepLength, const VectorType& curCentroid, const VectorType& nextCentroid) const;
      double     ComputeStepLength(double curStepLength, const VectorType& nextStepPath) const;
      VectorType GetRandomVector(unsigned long lSize) const;

      VectorType ConvertObjectivParameterToVector(const IndividualType* pIndividual) const;
    private:
      CMAMutation(Self const&); // Purposely not implemented.

      mutable long m_Mu;

      mutable MatrixType m_CurMatrix;
      mutable VectorType m_CurCentroid;
      mutable VectorType m_CurMatrixPath;
      mutable VectorType m_CurStepPath;
      mutable double m_CurStepLength;

      mutable unsigned long m_ObjectiveCount;

      SearchPointSelectorPointer m_SearchPointSelector;
      CentroidCombinatorPointer m_CentroidCombinator;

      
      VariateGeneratorType::Pointer m_RandomGenerator;
    } ; // end of class

  } // end of namespace ES
} // end of namespace FREE


#ifndef ITK_MANUAL_INSTANTIATION
#include "freESCMAMutation.txx"
#endif

#endif

---