freESIndividual.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: freESIndividual.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 __freESIndividual_h
#define __freESIndividual_h

#include "freESStrategicParameters.h"

#include "itkLightObject.h"

namespace FREE
{

  namespace ES
  {
    template <class TOPValueType, class TSPValueType, class TOValueType>
    class ITK_EXPORT Individual :
      public itk::LightObject
    {
    public:
      /* Standard class typedefs. */
      typedef Individual<TOPValueType, TSPValueType, TOValueType> Self;
      typedef itk::LightObject Superclass;
      typedef itk::SmartPointer<Self> Pointer;
      typedef itk::SmartPointer<const Self> ConstPointer;

      /* Method for creation through the object factory. */
      itkNewMacro(Self);

      /* Run-time type information (and related methods). */
      itkTypeMacro(Individual, LightObject);

      /* Other typedefs */
      typedef TOPValueType                                            ObjectiveParameterType;
      typedef std::vector<ObjectiveParameterType>                     ObjectiveParametersType;

      typedef TSPValueType                                            StrategicParameterValueType;
      typedef StrategicParameter<TSPValueType>                        StrategicParameterType;
      typedef typename StrategicParameterType::Pointer                StrategicParameterPointer;
      typedef StrategicParameters<TSPValueType>                       StrategicParametersType;
      typedef typename StrategicParametersType::Pointer               StrategicParametersPointer;
      typedef typename StrategicParameter<TSPValueType>::OriginIDType StrategicOriginIDType;
      typedef typename StrategicParameter<TSPValueType>::HandlingType StrategicParameterHandlingType;

      typedef TOValueType                                             ObjectiveValueType;

      typedef unsigned long ParameterIDType;
      typedef std::vector<ParameterIDType> ParameterIDsType;

      typedef unsigned long GenerationIDType;

      typedef unsigned long IndividualIDType;

      const ObjectiveParametersType& ObjectiveParameters() const
      {
        return m_ObjectiveParameters;
      };

      ObjectiveParametersType& ObjectiveParameters()
      {
        return m_ObjectiveParameters;
      };

      void ResetObjectiveParameters()
      {
        m_ObjectiveParameters.clear();
      };

      const StrategicParametersType& StrategicParameters() const
      {
        return *(m_StrategicParameters.GetPointer());
      };

      StrategicParametersType& StrategicParameters()
      {
        return *(m_StrategicParameters.GetPointer());
      };

      void ResetStrategicParameters()
      {
        m_StrategicParameters->clear();
      };

      GenerationIDType GetGenerationID() const {return m_GenerationID;};
      void SetGenerationID(GenerationIDType id) {m_GenerationID = id;};
      
      IndividualIDType GetIndividualID() const {return m_IndividualID;};
      void SetIndividualID(IndividualIDType id) {m_IndividualID = id;};

      ObjectiveValueType GetObjectiveValue() const {return m_ObjectiveValue;};
      void SetObjectiveValue(ObjectiveValueType value)
      {
        m_ObjectiveValue = value;
        m_ObjectiveValueIsSet = true;
      };

      bool GetObjectiveValueIsSet() const {return m_ObjectiveValueIsSet;};

      void ResetObjectiveValue()
      {
        m_ObjectiveValue = 0.0;
        m_ObjectiveValueIsSet = false;
      }

      virtual Pointer Clone() const;

      void operator=(Self const& individual);

      static bool ObjectiveValueIsGreater(const Self* pInd1, const Self* pInd2)
      {
        if (pInd1==0) throwStaticExceptionMacro("Error, passed individual 1 pointer is NULL.");
        if (pInd2==0) throwStaticExceptionMacro("Error, passed individual 2 pointer is NULL.");
        return pInd1->GetObjectiveValue() > pInd2->GetObjectiveValue(); 
      };

      static bool ObjectiveValueIsLesser(const Self* pInd1, const Self* pInd2)
      {
        if (pInd1==0) throwStaticExceptionMacro("Error, passed individual 1 pointer is NULL.");
        if (pInd2==0) throwStaticExceptionMacro("Error, passed individual 2 pointer is NULL.");
        return pInd1->GetObjectiveValue() < pInd2->GetObjectiveValue(); 
      };
    
    protected:
      Individual();

      virtual ~Individual(){};

      ObjectiveParametersType     m_ObjectiveParameters;
      StrategicParametersPointer  m_StrategicParameters;

      GenerationIDType m_GenerationID;

      IndividualIDType m_IndividualID;

      ObjectiveValueType m_ObjectiveValue;

      bool m_ObjectiveValueIsSet;

      virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;

    private:
      Individual(Self const&); // Purposely not implemented.
    };

  } //end namspsace ES
} // end namespace FREE

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

#endif // __freESIndividuals_h

---