freImageClassificationSOMetricController.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: freImageClassificationSOMetricController.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 __freImageClassificationSOMetricController_h
#define __freImageClassificationSOMetricController_h

#include "freSetupOptimizationMultiThreadMetricControllerBase.h"

#include "freImageClassificationSOMetric.h"

namespace FREE
{

        freControllerIDMacro(ImageClassificationSOMetricControllerBase, "ImageClassificationSOMetricBase");
template <class TControlledMetric>
class ImageClassificationSOMetricControllerBase : public SetupOptimizationMultiThreadMetricControllerBase<TControlledMetric>
{
public:  
  DeclareParameterMacro(ReferenceImage);
  DeclareParameterMacro(ResultImage);
  DeclareParameterMacro(LowerClassThreshold);
  DeclareParameterMacro(UpperClassThreshold);
  DeclareParameterMacro(FMeasureWeight);

        typedef TControlledMetric ComponentType;
  typedef SetupOptimizationMultiThreadMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageClassificationSOMetricControllerBase, SetupOptimizationMultiThreadMetricControllerBase);

protected:
        ImageClassificationSOMetricControllerBase()
        {
                //Profile settings
                this->UpdateControllerID(ControllerID::ImageClassificationSOMetricControllerBase);
                this->m_Description = "Base class for image classification metric.";
        };

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

                //Parameters
    profile.Parameters().AddParameter(Superclass::cParam_MetricScales,CtrlProfile::Parameter::PVTDouble,Superclass::cParamDsc_MetricScales,9,"1.0");
                profile.Parameters().AddParameter(cParam_ReferenceImage,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ReferenceImage,1,"");
                profile.Parameters().AddParameter(cParam_ResultImage,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ResultImage,1,"");
                profile.Parameters().AddParameter(cParam_LowerClassThreshold,CtrlProfile::Parameter::PVTDouble,cParamDsc_LowerClassThreshold,1,"1.0");
                profile.Parameters().AddParameter(cParam_UpperClassThreshold,CtrlProfile::Parameter::PVTDouble,cParamDsc_UpperClassThreshold,1,"255.0");
                profile.Parameters().AddParameter(cParam_FMeasureWeight,CtrlProfile::Parameter::PVTDouble,cParamDsc_FMeasureWeight,1,"1.0");
    profile.Parameters().AddParameter(cParam_MetricMinimize,Parameter::PVTBool,cParamDsc_MetricMinimize,1,"false");
};

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

                std::string sTempPath;
                IDPath referenceImagePath;
                IDPath resultImagePath;
    double dLower;
    double dUpper;
    double dFMWeight;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ReferenceImage,sTempPath);
                referenceImagePath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ResultImage,sTempPath);
                resultImagePath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_LowerClassThreshold,dLower);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UpperClassThreshold,dUpper);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_FMeasureWeight,dFMWeight);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");    
    
                pMainComponent->SetReferenceImagePath(referenceImagePath);
                pMainComponent->SetResultImagePath(resultImagePath);
                pMainComponent->SetLowerClassThreshold(dLower);
                pMainComponent->SetUpperClassThreshold(dUpper);
    pMainComponent->SetFMeasureWeight(dFMWeight);
        };

        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(); i++)
                {
                        rStatisticEntry.AddValue(Convert::ToStr(values[i]),pEntry->GetRefID()+i);
                }
        };

};

template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_ReferenceImage = "ReferenceImage";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_ReferenceImage = "IDPath of the reference image within the session of the adapted setups used as test basis.";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_ResultImage = "ResultImage";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_ResultImage = "IDPath of the result image of an adapted setup.";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_LowerClassThreshold = "LowerClassThreshold";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_LowerClassThreshold = "Lower pixel value threshold indicating class members.";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_UpperClassThreshold = "UpperClassThreshold";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_UpperClassThreshold = "Upper pixel value threshold indicating class members.";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParam_FMeasureWeight = "FMeasureWeight";
template <class TControlledMetric>
const char* const ImageClassificationSOMetricControllerBase<TControlledMetric>::cParamDsc_FMeasureWeight = "Weight of positive predictive value and sensitivity in the f-measure.";

        freControllerIDMacro(ImageClassification2DSOMetricController, "Image Classification 2D SO Metric");
class ImageClassification2DSOMetricController : public ImageClassificationSOMetricControllerBase< ImageClassificationSOMetric<2> >
{
public:  
  typedef ImageClassificationSOMetric<2> ComponentType;
  typedef ImageClassificationSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageClassification2DSOMetricController, ImageClassificationSOMetricControllerBase);

  ImageClassification2DSOMetricController();

};

        freControllerIDMacro(ImageClassification3DSOMetricController, "Image Classification 3D SO Metric");
class ImageClassification3DSOMetricController : public ImageClassificationSOMetricControllerBase< ImageClassificationSOMetric<3> >
{
public:  
  typedef ImageClassificationSOMetric<3> ComponentType;
  typedef ImageClassificationSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageClassification3DSOMetricController, ImageClassificationSOMetricControllerBase);

  ImageClassification3DSOMetricController();

};

} //end of namespace free

#endif

---