vPenalty.hh

Go to the documentation of this file.

/*
This file is part of CASToR.

    CASToR is free software: you can redistribute it and/or modify it under the
    terms of the GNU General Public License as published by the Free Software
    Foundation, either version 3 of the License, or (at your option) any later
    version.

    CASToR is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    details.

    You should have received a copy of the GNU General Public License along with
    CASToR (in file GNU_GPL.TXT). If not, see <http://www.gnu.org/licenses/>.

Copyright 2017-2019 all CASToR contributors listed below:

    --> Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Thibaut MERLIN, Mael MILLARDET, Simon STUTE, Valentin VIELZEUF

This is CASToR version 3.0.
*/

#ifndef VPENALTY_HH
#define VPENALTY_HH 1

#include "gVariables.hh"
#include "oImageDimensionsAndQuantification.hh"
#include "oImageSpace.hh"
#include "vDataFile.hh"
#include "oProjectionLine.hh"

class vPenalty
{
  // -------------------------------------------------------------------
  // Constructor & Destructor
  public:
    vPenalty();
    virtual ~vPenalty();


  // -------------------------------------------------------------------
  // Public member functions
  public:
  
    void ShowHelp();
    int CheckParameters();
    int Initialize();
    virtual int GlobalPreProcessingStep();
    virtual int LocalPreProcessingStep(int a_tbf, int a_rbf, int a_cbf, INTNB a_voxel, int a_th);
    virtual FLTNB ComputePenaltyValue(int a_tbf, int a_rbf, int a_cbf, INTNB a_voxel, int a_th) = 0;
    virtual FLTNB ComputeFirstDerivative(int a_tbf, int a_rbf, int a_cbf, INTNB a_voxel, int a_th) = 0;
    virtual FLTNB ComputeSecondDerivative(int a_tbf, int a_rbf, int a_cbf, INTNB a_voxel, int a_th) = 0;
  

  // -------------------------------------------------------------------
  // Public Get & Set functions
  public:
    inline void SetVerbose(int a_verbose)
           {m_verbose = a_verbose;}
    inline void SetImageDimensionsAndQuantification(oImageDimensionsAndQuantification* ap_ImageDimensionsAndQuantification)
           {mp_ImageDimensionsAndQuantification = ap_ImageDimensionsAndQuantification;}
    inline void SetImageSpace(oImageSpace* ap_ImageSpace)
           {mp_ImageSpace = ap_ImageSpace;}
    inline void SetPenaltyStrength(FLTNB a_penaltyStrength)
           {m_penaltyStrength = a_penaltyStrength;}
    inline FLTNB GetPenaltyStrength()
           {return m_penaltyStrength;}
    inline int GetPenaltyDerivativesOrder()
           {return m_penaltyDerivativesOrder;}
    inline void SetPenaltyID(const string& a_penaltyID)
           {m_penaltyID = a_penaltyID;}
    inline const string& GetPenaltyID()
           {return m_penaltyID;}


  // -----------------------------------------------------------------------------------------
  // Pure virtual private member functions that need to be implemented by child optimizers
  private:
    virtual int CheckSpecificParameters() = 0;
    virtual void ShowHelpSpecific() = 0;
    virtual int InitializeSpecific() = 0;


  // -------------------------------------------------------------------
  // Virtual public member functions that may be overloaded by specific child penalties
  public:
  
    virtual int ReadConfigurationFile( const string& a_configurationFile ) = 0;
    virtual int ReadOptionsList( const string& a_optionsList ) = 0;
    
  // -------------------------------------------------------------------
  // Data members
  protected:
    // Penalty ID
    string m_penaltyID;                    
    // Image dimensions
    oImageDimensionsAndQuantification* 
      mp_ImageDimensionsAndQuantification; 
    oImageSpace* mp_ImageSpace;            
    // Verbosity
    int m_verbose;                         
    // Order of penalty derivatives
    int m_penaltyDerivativesOrder;         
    FLTNB m_penaltyStrength;               
};


// ---------------------------------------------------------------------
// Part of code that manages the auto declaration of children classes
// ---------------------------------------------------------------------

// Macro for the function that creates the object
#define FUNCTION_PENALTY(CLASS) \
  static vPenalty *make_penalty() { return new CLASS(); };

// Macro for the class that links the appropriate function to the map of objects
#define CLASS_PENALTY(NAME,CLASS)                                                          \
  class NAME##PenaltyCreator                                                               \
  {                                                                                        \
    public:                                                                                \
      NAME##PenaltyCreator()                                                               \
        { sAddonManager::GetInstance()->mp_listOfPenalties[#NAME] = CLASS::make_penalty; } \
  };                                                                                       \
  static NAME##PenaltyCreator PenaltyCreator##NAME;

#endif