freConstrainedImageClassificationSOMetricController.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: freConstrainedImageClassificationSOMetricController.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 __freConstrainedImageClassificationSOMetricController_h
#define __freConstrainedImageClassificationSOMetricController_h

#include "freImageClassificationSOMetricController.h"

#include "freConstrainedImageClassificationSOMetric.h"

namespace FREE
{

        freControllerIDMacro(ConstrainedImageClassificationSOMetricControllerBase, "ConstrainedImageClassificationSOMetricBase");
template <class TControlledMetric>
class ConstrainedImageClassificationSOMetricControllerBase : public ImageClassificationSOMetricControllerBase<TControlledMetric>
{
public:  
  DeclareParameterMacro(MaxConstraintPenalty);
  DeclareParameterMacro(FailureThreshold);
  DeclareParameterMacro(Constraints);

        typedef TControlledMetric ComponentType;
  typedef ImageClassificationSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedImageClassificationSOMetricControllerBase, ImageClassificationSOMetricControllerBase);

protected:
        ConstrainedImageClassificationSOMetricControllerBase()
        {
                //Profile settings
                this->UpdateControllerID(ControllerID::ConstrainedSetupOptimizationMetricControllerBase);
                this->UpdateControllerID(ControllerID::ImageClassificationSOMetricControllerBase);
                this->UpdateControllerID(ControllerID::ConstrainedImageClassificationSOMetricControllerBase);
                this->m_Description = "Base class for image difference setup optimization metric which supports constraints.";
        };

  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                  const SessionComponentCache* pComponentCache,
                  bool bRegardOldSetup) const
  {
    Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

                //Parameters
                profile.Parameters().AddParameter(cParam_Constraints,CtrlProfile::Parameter::PVTString,cParamDsc_Constraints,4,"",-1);
                profile.Parameters().AddParameter(cParam_MaxConstraintPenalty,CtrlProfile::Parameter::PVTDouble,cParamDsc_MaxConstraintPenalty,1,"0");
                profile.Parameters().AddParameter(cParam_FailureThreshold,CtrlProfile::Parameter::PVTDouble,cParamDsc_FailureThreshold,1,"0.0");
  };

        virtual void ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
        {
                Superclass::ActualizeMainComponent(pMainComponent, pComponentCache,
                                                                                                                                                         pSessionInfo, iActLevel);

                double dMaxPenalty;
                double dThreshold;

    Parameter::Pointer smpConstraints = SessionAccessor::GetParameter(pComponentCache,cParam_Constraints);
                if (smpConstraints.IsNull()) throwExceptionMacro("Missing parameter: " << cParam_Constraints);

                for (unsigned int index = 0; index < smpConstraints->LayerCount(); index++)
                {
                        int iParamID;
                        std::string sRelationType;
                        std::string sTerm;
                        double dBarrierSize;

                        if (!smpConstraints->GetParameterValue(iParamID,0,index)) throwExceptionMacro("Faulty parameter; cannot retrieve parameter id. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(sRelationType,1,index)) throwExceptionMacro("Faulty parameter; cannot retrieve relation type. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(sTerm,2,index)) throwExceptionMacro("Faulty parameter; cannot retrieve constraint term. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(dBarrierSize,3,index)) throwExceptionMacro("Faulty parameter; cannot retrieve barrier size. constraint #: " << index);

      SetupParameterConstraint::Pointer smpNewCnstr = SetupParameterConstraint::New(iParamID,Convert::ToRelationType(sRelationType),sTerm);
                        pMainComponent->AddConstraint(*(smpNewCnstr.GetPointer()),dBarrierSize);
                }

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_MaxConstraintPenalty,dMaxPenalty);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_FailureThreshold,dThreshold);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");    

                pMainComponent->SetMaxConstraintPenalty(dMaxPenalty);
                pMainComponent->SetFailureThreshold(dThreshold);
        };

        void
        SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
        {
                typename ComponentType::DecomposedMeasureType values = pMainComponent->GetCurrentDecomposedValue();

                std::string sIDPath = pMainComponentCache->GetIDPath();
                StatisticValueDefinition* pEntry = rDictionary.GetValueDefinitionByName(sIDPath,"mean sensitivity");
            
                if (!pEntry) //Entry is not recorded yet, so do so.
                {
                        pEntry = rDictionary.AddValueDefinition(sIDPath,"mean sensitivity", "mean sensitivity");
                        rDictionary.AddValueDefinition(sIDPath,"std sensitivity", "standard deviation of sensitivity.");
                        rDictionary.AddValueDefinition(sIDPath,"min sensitivity", "minimum sensitivity");
                        rDictionary.AddValueDefinition(sIDPath,"max sensitivity", "maximum sensitivity");
                  rDictionary.AddValueDefinition(sIDPath,"mean specificity", "mean specificity");
                        rDictionary.AddValueDefinition(sIDPath,"std specificity", "standard deviation of specificity.");
                        rDictionary.AddValueDefinition(sIDPath,"min specificity", "minimum specificity");
                        rDictionary.AddValueDefinition(sIDPath,"max specificity", "maximum specificity");
                  rDictionary.AddValueDefinition(sIDPath,"mean ppv", "mean ppv (positive predictive value)");
                        rDictionary.AddValueDefinition(sIDPath,"std ppv", "standard deviation of ppv.");
                        rDictionary.AddValueDefinition(sIDPath,"min ppv", "minimum ppv");
                        rDictionary.AddValueDefinition(sIDPath,"max ppv", "maximum ppv");
                  rDictionary.AddValueDefinition(sIDPath,"mean npv", "mean npv (negative predictive value)");
                        rDictionary.AddValueDefinition(sIDPath,"std npv", "standard deviation of npv.");
                        rDictionary.AddValueDefinition(sIDPath,"min npv", "minimum npv");
                        rDictionary.AddValueDefinition(sIDPath,"max npv", "maximum npv");
                  rDictionary.AddValueDefinition(sIDPath,"mean fm", "mean f-measure (negative predictive value)");
                        rDictionary.AddValueDefinition(sIDPath,"std fm", "standard deviation of fm.");
                        rDictionary.AddValueDefinition(sIDPath,"min fm", "minimum fm");
                        rDictionary.AddValueDefinition(sIDPath,"max fm", "maximum fm");
                        rDictionary.AddValueDefinition(sIDPath,"failure", "number of failed evaluations");
                        rDictionary.AddValueDefinition(sIDPath,"mean duration", "mean duration of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"std duration", "standard deviation of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"min duration", "minimum duration of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"max duration", "maximum duration of an evaluation (tenth of a second).");
 
                        for (unsigned int i = 0; i<values.Size()-25; i++)
                        {
                                rDictionary.AddValueDefinition(sIDPath,"constraint penalty #"+Convert::ToStr(i), "penalty of the constraint #"+Convert::ToStr(i));
                        }
                }
          
                for (unsigned int i = 0; i<values.Size(); i++)
                {
                        rStatisticEntry.AddValue(Convert::ToStr(values[i]),pEntry->GetRefID()+i);
                }
        };

};

template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_Constraints = "Constraints";
template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_Constraints = "The constraints of the metric. First element is the ID of the constrained parameter, second value indicates the type of relation (0: equal; 1: lesser or equal; 2: greater or equal). The third value is the constraint term. The fourth value is the barrier size.\nParameter IDs, if used in the term have an underscore as prefix.\nExample: 1 | 2 | (_2 * 4) + _3\nBy this constrained parameter 1 should be greater or equal four times parameter 2 + parameter 3.";

template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_MaxConstraintPenalty = "MaxConstraintPenalty";
template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_MaxConstraintPenalty = "Maximum penalty the barrier function of a constraint can return. This value will be scaled be metric scales, if there is any defined for a constrained.";

template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_FailureThreshold = "FailureThreshold";
template <class TControlledMetric>
const char* const ConstrainedImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_FailureThreshold = "Threshold for the penalty computation, if the penalty is equal or above this threshold, the computation will be accounted as a failure. No evaluations of the adaptations will be done. A value of 0.0 or less deactivates the threshold.";

        freControllerIDMacro(ConstrainedImageClassification2DSOMetricController, "Constrained Image Classification 2D SO Metric");
class ConstrainedImageClassification2DSOMetricController : public ConstrainedImageClassificationSOMetricControllerBase< ConstrainedImageClassificationSOMetric<2> >
{
public:  
  typedef ConstrainedImageClassificationSOMetric<2> ComponentType;
  typedef ConstrainedImageClassificationSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedConstrainedImageClassification2DSOMetricController, ConstrainedImageClassificationSOMetricControllerBase);

  ConstrainedImageClassification2DSOMetricController();

};

        freControllerIDMacro(ConstrainedImageClassification3DSOMetricController, "Constrained Image Classification 3D SO Metric");
class ConstrainedImageClassification3DSOMetricController : public ConstrainedImageClassificationSOMetricControllerBase< ConstrainedImageClassificationSOMetric<3> >
{
public:  
  typedef ConstrainedImageClassificationSOMetric<3> ComponentType;
  typedef ConstrainedImageClassificationSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedConstrainedImageClassification3DSOMetricController, ConstrainedImageClassificationSOMetricControllerBase);

  ConstrainedImageClassification3DSOMetricController();

};

} //end of namespace free

#endif

---