oDeformationManager.cc

Go to the documentation of this file.

/*
  Implementation of class oDeformationManager

  - separators: X
  - doxygen: X
  - default initialization: X
  - CASTOR_DEBUG: X
  - CASTOR_VERBOSE: X
*/

#include "oDeformationManager.hh"
#include "sAddonManager.hh"



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn oDeformationManager
  \brief Constructor of oDeformationManager. Simply set all data members to default values.
*/
oDeformationManager::oDeformationManager()
{
  // Image dimensions
  mp_ID = NULL;
  // Options for each deformation type
  m_optionsResp = "";
  m_optionsCard = "";
  m_optionsInv = "";
  // Deformation objects and associated bool
  mp_DeformationResp = NULL;
  mp_DeformationCard = NULL;
  mp_DeformationInv = NULL;
  m_UseDeformationResp = false;
  m_UseDeformationCard = false;
  m_UseDeformationInv = false;
  // Variable indicating the current gate for the different types of motion
  m_currentRespGate = 0;
  m_currentCardGate = 0;
  m_currentPMotionIndex = 0;
  // Number of gates for cyclic motion
  m_nbRespGates = -1;
  m_nbCardGates = -1;
  // Verbosity
  m_verbose = -1;
  // Data mode
  m_dataMode = -1;
  // Not checked yet
  m_checked = false;
  // Not initialized yet
  m_initialized = false;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ~oDeformationManager
  \brief Destructor of oDeformationManager. Free memory from all allocated tabs.
*/
oDeformationManager::~oDeformationManager() 
{
  // Delete deformation objects
  if (m_initialized)
  {
    if (mp_DeformationResp != NULL) delete mp_DeformationResp;
    if (mp_DeformationCard != NULL) delete mp_DeformationCard;
    if (mp_DeformationInv != NULL) delete mp_DeformationInv;
  }
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn InstantiateImageForDeformation
  \param oImageSpace* ap_Image : required to call oImageSpace instanciation functions
  \brief If deformation is enabled, ask the Image Space to Instantiate the temporary backward image for deformation
         If reconstruction is in histogram mode, the temporal sensitivity image is instanciated as well
*/
void oDeformationManager::InstantiateImageForDeformation(oImageSpace* ap_Image)
{
  if ( m_UseDeformationResp || m_UseDeformationCard || m_UseDeformationInv )
  {
    // Verbose
    if(m_verbose>=2) Cout("oDeformationManager::InstantiateImageForDeformation() -> Instantiate buffer images"<< endl);
    // Instantiate buffer image for backward deformation
    ap_Image->InstantiateBwdImageForDeformation();
    // In histogram mode, need another buffer image for sensitivity deformation
    if (m_dataMode == MODE_HISTOGRAM) ap_Image->InstantiateSensImageForDeformation();
  }
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn DeallocateImageForDeformation
  \param oImageSpace* ap_Image : required to call oImageSpace deallocation functions
  \brief If deformation is enabled, ask the Image Space to free memory of the temporary backward image for deformation
         If reconstruction is in histogram mode, the temporal sensitivity image is deallocated as well
*/ 
void oDeformationManager::DeallocateImageForDeformation(oImageSpace* ap_Image)
{
  if ( m_UseDeformationResp || m_UseDeformationCard || m_UseDeformationInv ) 
  {
    // Verbose
    if(m_verbose>=2) Cout("oDeformationManager::DeallocateImageForDeformation() -> Deallocate buffer images"<< endl);
    // Deallocate backward buffer image
    ap_Image->DeallocateBwdImageForDeformation();
    // In histogram mode, deallocate sensitivity buffer image
    if (m_dataMode == MODE_HISTOGRAM) ap_Image->DeallocateSensImageForDeformation();
  }
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn InitImageForDeformation
  \param oImageSpace* ap_Image : required to call oImageSpace initialization functions
  \brief If deformation is enabled, ask the Image Space to initialize the temporary backward image for deformation
         If reconstruction is in histogram mode, the temporal sensitivity image is initialized as well
*/
void oDeformationManager::InitImageForDeformation(oImageSpace* ap_Image)
{
  if ( m_UseDeformationResp || m_UseDeformationCard || m_UseDeformationInv ) 
  {
    if(m_verbose>=2) Cout("oDeformationManager::InitImageForDeformation() -> Initialize buffer images"<< endl);
    ap_Image->InitBwdImageForDeformation();
    if (m_dataMode == MODE_HISTOGRAM) ap_Image->InitSensImageForDeformation();
  }
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn CheckParameters
  \brief This function is used to check parameters after the latter
         have been all set using Set functions.
  \return 0 if success, positive value otherwise.
*/
int oDeformationManager::CheckParameters()
{
  // Verbose
  if (m_verbose>=4) Cout("oDeformationManager::CheckParameters() -> Check parameters before initialization"<< endl);
  // Check image dimensions
  if (mp_ID==NULL)
  {
    Cerr("***** oDeformationManager::CheckParameters() -> No image dimensions provided !" << endl);
    return 1;
  }
  // Check resp gates
  if (m_nbRespGates<0)
  {
    Cerr("***** oDeformationManager::CheckParameters() -> Wrong number of respiratory gates !" << endl);
    return 1;
  }
  // Check card gates
  if (m_nbCardGates<0)
  {
    Cerr("***** oDeformationManager::CheckParameters() -> Wrong number of respiratory gates !" << endl);
    return 1;
  }
  // Check verbosity
  if (m_verbose<0)
  {
    Cerr("***** oDeformationManager::CheckParameters() -> Wrong verbosity level provided !" << endl);
    return 1;
  }
  // Check data mode
  if (m_dataMode<0)
  {
    Cerr("***** oDeformationManager::CheckParameters() -> Wrong data mode provided ! (should be =0 (list-mode) or =1 (histogram)" << endl);
    return 1;
  }
  // Normal end
  m_checked = true;
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn Initialize
  \brief Set the flags for the different motion types and instanciate/initialize deformation objects
         through the ParseOptionsAndInitializeDeformations() private function.
  \return 0 if success, positive value otherwise.
*/
int oDeformationManager::Initialize()
{
  // Forbid initialization without check
  if (!m_checked)
  {
    Cerr("***** oDeformationManager::Initialize() -> Must call CheckParameters() before Initialize() !" << endl);
    return 1;
  }
  
  // Check resp options 
  if (m_optionsResp=="") m_UseDeformationResp = false;
  else m_UseDeformationResp = true;
  // Check card options
  if (m_optionsCard=="") m_UseDeformationCard = false;
  else m_UseDeformationCard = true;
  // Check inv options
  if (m_optionsInv=="") m_UseDeformationInv = false;
  else m_UseDeformationInv = true;

  // Initialize current gates and involuntary motion indices
  m_currentRespGate = 0;
  m_currentCardGate = 0;
  m_currentPMotionIndex = 0;

  // Return if no deformation
  if (!m_UseDeformationCard && !m_UseDeformationInv && !m_UseDeformationResp)
  {
    m_initialized = true;
    return 0;
  }

  // Verbose
  if (m_verbose>=1) Cout("oDeformationManager::Initialize() -> Initialize deformations" << endl);
  
  // Parse deformation options and initialize them
  if (ParseOptionsAndInitializeDeformations())
  {
    Cerr("***** oDeformationManager::Initialize() -> A problem occured while parsing deformation options and initializing them !" << endl);
    return 1;
  }

  // Normal end
  m_initialized = true;
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ParseOptionsAndInitializeProjectors
  \brief Parse respiratory/cardiac/involuntary patient motion options contained in the previously provided
         strings. This function is called inside the Initialize() function.
  \details Manage the options reading and initialize specific vDeformation
           Options are a string containing first the name of the deformation,
           then either a ':' and a configuration file specific to the deformation
           - or - as many ',' as needed parameters for this deformation.
           Specific pure virtual functions of the vDeformation are used to read parameters and initialize them.
  \todo  Some cleaning if we merge respiratory and cardiac motion objects
  \return 0 if success, positive value otherwise
*/
int oDeformationManager::ParseOptionsAndInitializeDeformations()
{
  if (m_verbose>=2) Cout("oDeformationManager::ParseOptionsAndInitializeDeformations ..."<< endl);
    
  string deformation = "";
  string list_options = "";
  string file_options = "";

  // This is for the automatic initialization of the deformations
  typedef vDeformation *(*maker_deformation) ();
  
  // Get deformation's list from addon manager
  std::map <string,maker_deformation> list = sAddonManager::GetInstance()->mp_listOfDeformations;

  size_t colon, comma;
  
  // ---------------------------------------------------------------------------------------------------
  // Manage deformation for respiratory motion
  // ---------------------------------------------------------------------------------------------------
  if (m_UseDeformationResp)
  {    
    // ______________________________________________________________________________
    // Get the deformation name in the options and isolate the real deformation's options

    // Search for a colon ":", this indicates that a configuration file is provided after the deformation name
    colon = m_optionsResp.find_first_of(":");
    comma = m_optionsResp.find_first_of(",");

    // Case 1: we have a colon
    if (colon!=string::npos)
    {
      // Get the deformation name before the colon
      deformation = m_optionsResp.substr(0,colon);
      // Get the configuration file after the colon
      file_options = m_optionsResp.substr(colon+1);
      // List of options is empty
      list_options = "";
    }
    // Case 2: we have a comma
    else if (comma!=string::npos)
    {
      // Get the deformation name before the first comma
      deformation = m_optionsResp.substr(0,comma);
      // Get the list of options after the first comma
      list_options = m_optionsResp.substr(comma+1);
      // Configuration file is empty
      file_options = "";
    }
    // Case 3: no colon and no comma (a single deformation name)
    else
    {
      // Get the deformation name
      deformation = m_optionsResp;
      // Configuration file is empty
      file_options = "";
      // List of options is empty
      list_options = "";
    }
  
    // Create the deformation
    if (list[deformation]) mp_DeformationResp = list[deformation]();
    else
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> Deformation '" << deformation << "' does not exist !" << endl);
      sAddonManager::GetInstance()->ShowHelpDeformation();
      return 1;
    }
    // Set parameters
    mp_DeformationResp->SetImageDimensionsAndQuantification(mp_ID);
    mp_DeformationResp->SetVerbose(m_verbose);
    mp_DeformationResp->SetNbTransformations(m_nbRespGates);

  
    // Provide configuration file if any
    if (file_options!="" && mp_DeformationResp->ReadAndCheckConfigurationFile(file_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while reading and checking respiratory deformation's configuration file !" << endl);
      return 1;
    }
    // Provide options if any
    if (list_options!="" && mp_DeformationResp->ReadAndCheckOptionsList(list_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while parsing and reading respiratory deformation's options !" << endl);
      return 1;
    }
  
    // Check parameters
    if (mp_DeformationResp->CheckParameters())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while checking respiratory deformation parameters !" << endl);
      return 1;
    }
    // Initialize the deformation
    if (mp_DeformationResp->Initialize())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while initializing respiratory deformation !" << endl);
      return 1;
    }

    // Tell the DynamicDataManager that respiratory motion is enabled
    mp_ID->SetRespMotionFlagOn(); // Probably useless since the DynamicDataManager already knows that normally ?
  }

  // ---------------------------------------------------------------------------------------------------
  // Manage deformation for cardiac motion
  // ---------------------------------------------------------------------------------------------------
  if (m_UseDeformationCard)
  {
    // ______________________________________________________________________________
    // Get the deformation name in the options and isolate the real deformation's options
  
    // Search for a colon ":", this indicates that a configuration file is provided after the deformation name
    colon = m_optionsCard.find_first_of(":");
    comma = m_optionsCard.find_first_of(",");
  
    // Case 1: we have a colon
    if (colon!=string::npos)
    {
      // Get the deformation name before the colon
      deformation = m_optionsCard.substr(0,colon);
      // Get the configuration file after the colon
      file_options = m_optionsCard.substr(colon+1);
      // List of options is empty
      list_options = "";
    }
    // Case 2: we have a comma
    else if (comma!=string::npos)
    {
      // Get the deformation name before the first comma
      deformation = m_optionsCard.substr(0,comma);
      // Get the list of options after the first comma
      list_options = m_optionsCard.substr(comma+1);
      // Configuration file is empty
      file_options = "";
    }
    // Case 3: no colon and no comma (a single deformation name)
    else
    {
      // Get the deformation name
      deformation = m_optionsCard;
      // Configuration file is empty
      file_options = "";
      // List of options is empty
      list_options = "";
    }

    // Create the deformation
    if (list[deformation]) mp_DeformationCard = list[deformation]();
    else
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> Deformation '" << deformation << "' does not exist !" << endl);
      return 1;
    }
    // Set parameters
    mp_DeformationCard->SetImageDimensionsAndQuantification(mp_ID);
    mp_DeformationCard->SetVerbose(m_verbose);
    mp_DeformationCard->SetNbTransformations(m_nbCardGates);
    // Provide configuration file if any
    if (file_options!="" && mp_DeformationCard->ReadAndCheckConfigurationFile(file_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while reading and checking cardiac deformation's configuration file !" << endl);
      return 1;
    }
    // Provide options if any
    if (list_options!="" && mp_DeformationCard->ReadAndCheckOptionsList(list_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while parsing and reading cardiac deformation's options !" << endl);
      return 1;
    }
    // Check parameters
    if (mp_DeformationCard->CheckParameters())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while checking cardiac deformation parameters !" << endl);
      return 1;
    }
    // Initialize the deformation
    if (mp_DeformationCard->Initialize())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while initializing cardiac deformation !" << endl);
      return 1;
    }
    // Tell the DynamicDataManager that cardiac motion is enabled
    mp_ID->SetCardMotionFlagOn();
  }

  // ---------------------------------------------------------------------------------------------------
  // Manage deformation for involuntary motion
  // ---------------------------------------------------------------------------------------------------
  if (m_UseDeformationInv)
  {
    // ______________________________________________________________________________
    // Get the deformation name in the options and isolate the real deformation's options
  
    // Search for a colon ":", this indicates that a configuration file is provided after the deformation name
    colon = m_optionsCard.find_first_of(":");
    comma = m_optionsCard.find_first_of(",");
  
    // Case 1: we have a colon
    if (colon!=string::npos)
    {
      // Get the deformation name before the colon
      deformation = m_optionsInv.substr(0,colon);
      // Get the configuration file after the colon
      file_options = m_optionsInv.substr(colon+1);
      // List of options is empty
      list_options = "";
    }
    // Case 2: we have a comma
    else if (comma!=string::npos)
    {
      // Get the deformation name before the first comma
      deformation = m_optionsInv.substr(0,comma);
      // Get the list of options after the first comma
      list_options = m_optionsInv.substr(comma+1);
      // Configuration file is empty
      file_options = "";
    }
    // Case 3: no colon and no comma (a single deformation name)
    else
    {
      // Get the deformation name
      deformation = m_optionsInv;
      // Configuration file is empty
      file_options = "";
      // List of options is empty
      list_options = "";
    }
  
    // Create the deformation
    if (list[deformation]) mp_DeformationInv = list[deformation]();
    else
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> Deformation '" << deformation << "' does not exist !" << endl);
      return 1;
    }
    // Set parameters
    mp_DeformationInv->SetImageDimensionsAndQuantification(mp_ID);
    mp_DeformationInv->SetVerbose(m_verbose);
    mp_DeformationInv->SetNbTransformations(1); // TODO !


    // Provide configuration file if any
    if (file_options!="" && mp_DeformationInv->ReadAndCheckConfigurationFile(file_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while reading and checking involuntary motion deformation's configuration file !" << endl);
      return 1;
    }
    // Provide options if any
    if (list_options!="" && mp_DeformationInv->ReadAndCheckOptionsList(list_options))
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while parsing and reading involuntary motion deformation's options !" << endl);
      return 1;
    }
    // Check parameters
    if (mp_DeformationInv->CheckParameters())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while checking involuntary motion deformation parameters !" << endl);
      return 1;
    }
    // Initialize the deformation
    if (mp_DeformationInv->Initialize())
    {
      Cerr("***** oDeformationManager::ParseOptionsAndInitializeDeformations() -> A problem occured while initializing involuntary motion deformation !" << endl);
      return 1;
    }
    
    // Tell the DynamicDataManager that involuntary motion is enabled
    mp_ID->SetPMotionFlagOn();
  }

  // Normal end
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ApplyDeformationForSensitivityGeneration
  \param oImageSpace* ap_Image : required to access oImageSpace image matrices
  \param int a_defDirection : direction of the deformation (forward/backward)
  \param int a_defType : Nature of the motion (Respiratory/Cardiac/Involuntary Patient)
  \param int fr
  \param int rg
  \param int cg
  \brief Apply deformations during the list-mode sensitivity image generation 
  \details Perform deformation of type 'a_defType' on the forward_image or the backward_image matrices corresponding to the current fr, rg, cg (if any), and depending on the defDirection.
  \todo Some changes required if we merge respiratory/cardiac motion objects
  \todo Check and implement patient motion
  \return 0 if success, positive value otherwise
*/
int oDeformationManager::ApplyDeformationForSensitivityGeneration(oImageSpace* ap_Image, int a_defDirection, int a_defType, int fr, int rg, int cg) 
{
  #ifdef CASTOR_DEBUG
  if (!m_initialized)
  {
    Cerr("***** oDeformationManager::ApplyDeformationForSensitivityGeneration() -> Called while not initialized !" << endl);
    Exit(EXIT_DEBUG);
  }
  #endif
  
  if (a_defType == DEF_RESP_MOT && m_UseDeformationResp)
  {
    if (m_verbose>=2)
    {
      string direction = "FORWARD"; if (a_defDirection==BACKWARD_DEFORMATION) direction = "BACKWARD";
      Cout("oDeformationManager::ApplyDeformationForSensitivityGeneration()-> '" << direction
                           << "' Deformation for respiratory motion, for resp gate " <<rg
                           << " and card gate " <<cg<<"." <<endl);
    }
    if (mp_DeformationResp->PerformSensitivityDeformation(ap_Image, a_defDirection, rg, fr, rg, cg) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationForSensitivityGeneration()-> An error occured while performing deformation for respiratory motion correction for the sensitivity image generation !" << endl);
      return 1;
    }
  }
    
  if (a_defType == DEF_CARD_MOT && m_UseDeformationCard)
  {
    if (m_verbose>=2)
    {
      string direction = "FORWARD"; if (a_defDirection==BACKWARD_DEFORMATION) direction = "BACKWARD";
      Cout("oDeformationManager::ApplyDeformationForSensitivityGeneration()-> '" << direction
                           << "' Deformation for cardiac motion, for resp gate " <<rg
                           << " and card gate " <<cg<<"." <<endl);
    }
    if (mp_DeformationCard->PerformSensitivityDeformation(ap_Image, a_defDirection, cg, fr, rg, cg) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationForSensitivityGeneration()-> An error occured while performing deformation for cardiac motion correction for the sensitivity image generation !" << endl);
      return 1;
    }
  }
    
  if (a_defType == DEF_IPAT_MOT && m_UseDeformationInv)
  {
    if (m_verbose>=2)
    {
      string direction = "FORWARD"; if (a_defDirection==BACKWARD_DEFORMATION) direction = "BACKWARD";
      Cout("oDeformationManager::ApplyDeformationForSensitivityGeneration()-> '" << direction
                           << "' Deformation for involuntary patient motion, for resp gate " <<rg
                           << " and card gate " <<cg<<"." <<endl);
    }
    //if (mp_DeformationInv->PerformSensitivityDeformation(ap_Image, a_defDirection, GET_INDEX_HERE!!!, fr, rg, cg) ) //TODO
    //{
    //  Cerr("***** oDeformationManager::ApplyDeformationForSensitivityGeneration()-> An error occured while performing deformation for patient involuntary motion correction for the sensitivity image generation !" << endl);
    //  return 1;
    //}
  }
  
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ApplyDeformationsToForwardImage
  \param oImageSpace* ap_Image : required to access oImageSpace image matrices
  \brief Apply initial deformations on the forwardImage before loop on events
  \todo May not be required anymore for the current implementation (always reference position at start of subset)
  \return 0 if success, positive value otherwise
*/
int oDeformationManager::ApplyDeformationsToForwardImage(oImageSpace* ap_Image) 
{
  #ifdef CASTOR_DEBUG
  if (!m_initialized)
  {
    Cerr("***** oDeformationManager::ApplyDeformationsToForwardImage() -> Called while not initialized !" << endl);
    Exit(EXIT_DEBUG);
  }
  #endif
  
  int fr = mp_ID->GetCurrentTimeFrame(0);
  int rimg = mp_ID->GetCurrentRespImage(0);
  int cimg = mp_ID->GetCurrentCardImage(0);
  
  fr = (fr<0) ? 0 : fr ;
  
  if (m_UseDeformationResp)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationToForwardImage-> Deformation of respiratory type, gate # " << mp_ID->GetCurrentRespGate(0) 
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"."
                        << " We are Frame # " << fr <<endl);
    if(mp_DeformationResp->ApplyDeformationsToForwardImage(ap_Image, mp_ID->GetCurrentRespGate(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToForwardImage()-> An error occured while performing initial deformation of the forward image !" << endl);
      return 1;
    }
  }
    
  if (m_UseDeformationCard)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationToForwardImage-> Deformation of cardiac type, gate # " << mp_ID->GetCurrentCardGate(0)
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"."
                        << " We are Frame # " << fr <<endl);
    if(mp_DeformationCard->ApplyDeformationsToForwardImage(ap_Image, mp_ID->GetCurrentCardGate(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToForwardImage()-> An error occured while performing initial deformation of the forward image !" << endl);
      return 1;
    }
  }
    
  if (m_UseDeformationInv)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationToForwardImage-> Deformation of involuntary motion type, gate # " << mp_ID->GetCurrentPMotionIndex(0)
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"." <<endl);
    if(mp_DeformationInv->ApplyDeformationsToForwardImage(ap_Image, mp_ID->GetCurrentPMotionIndex(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToForwardImage()-> An error occured while performing initial deformation of the forward image !" << endl);
      return 1;
    }
  }
  
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PerformDeformation
  \param oImageSpace* ap_Image : required to access oImageSpace image matrices
  \brief Apply deformations during reconstruction
  \details Call the eponym function for the deformation object, 
           as well as PerformHistoSensitivityDeformation() if data mode is histogram.
  \todo why the check on frames ?
  \return 0 if success, positive value otherwise
*/
int oDeformationManager::PerformDeformation(oImageSpace* ap_Image)
{
  #ifdef CASTOR_DEBUG
  if (!m_initialized)
  {
    Cerr("***** oDeformationManager::PerformDeformation() -> Called while not initialized !" << endl);
    Exit(EXIT_DEBUG);
  }
  #endif
  
  int fr = mp_ID->GetCurrentTimeFrame(0);
  int rimg = mp_ID->GetCurrentRespImage(0);
  int cimg = mp_ID->GetCurrentCardImage(0);  
  
  fr = (fr<0) ? 0 : fr ;
  
  if (m_UseDeformationResp && (m_currentRespGate!=mp_ID->GetCurrentRespGate(0)) )
  {
    if(m_verbose >=3) Cout("oDeformationManager::PerformDeformation-> Deformation of respiratory type, gate # " << mp_ID->GetCurrentRespGate(0)
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"." 
                        << " We are Frame # " << fr << endl);
    if(mp_DeformationResp->PerformDeformation(ap_Image, mp_ID->GetCurrentRespGate(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing image deformation during the reconstruction !" << endl);
      return 1;
    }
    
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM )
      if( mp_DeformationResp->PerformHistoSensitivityDeformation(ap_Image, mp_ID->GetCurrentRespGate(0), fr, rimg, cimg) )
      {
        Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing sensitivity image deformation (histogram mode) during the reconstruction !" << endl);
        return 1;
      }

    m_currentRespGate = mp_ID->GetCurrentRespGate(0);
  }
    
  if (m_UseDeformationCard && (m_currentCardGate!=mp_ID->GetCurrentCardGate(0)) )
  {
    if(m_verbose >=3) Cout("oDeformationManager::PerformDeformation-> Deformation of cardiac type, gate # " << mp_ID->GetCurrentCardGate(0)
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"." <<endl);
    if(mp_DeformationCard->PerformDeformation(ap_Image, mp_ID->GetCurrentCardGate(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing image deformation during the reconstruction !" << endl);
      return 1;
    }
    
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM )
      if( mp_DeformationCard->PerformHistoSensitivityDeformation(ap_Image, mp_ID->GetCurrentCardGate(0), fr, rimg, cimg) )
      {
        Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing sensitivity image deformation (histogram mode) during the reconstruction !" << endl);
        return 1;
      }
      
    m_currentCardGate = mp_ID->GetCurrentCardGate(0);
  }
    
  if (m_UseDeformationInv && (m_currentPMotionIndex!=mp_ID->GetCurrentPMotionIndex(0)) )
  {
    // TODO: pay attention here to the indexation because the deformations are based on a number of time-triggers
    if(m_verbose >=3) Cout("oDeformationManager::PerformDeformation-> Deformation of involuntary motion type, gate # " << mp_ID->GetCurrentPMotionIndex(0)
                        << ", for resp image " <<rimg
                        << " and card image " <<cimg<<"." <<endl);
    if(mp_DeformationInv->PerformDeformation(ap_Image, mp_ID->GetCurrentPMotionIndex(0), fr, rimg, cimg) )
    {
      Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing image deformation during the reconstruction !" << endl);
      return 1;
    }
    
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM )
      if( mp_DeformationInv->PerformHistoSensitivityDeformation(ap_Image, mp_ID->GetCurrentPMotionIndex(0), fr, rimg, cimg) )
      {
        Cerr("***** oDeformationManager::PerformDeformation()-> An error occured while performing sensitivity image deformation (histogram mode) during the reconstruction !" << endl);
        return 1;
      }
      
    m_currentPMotionIndex = mp_ID->GetCurrentPMotionIndex(0);
  }
  
  return 0;
}

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ApplyDeformationsToBackwardImage
  \param oImageSpace* ap_Image : required to access oImageSpace image matrices
  \brief Apply final backward deformations on the backward image
  \details Call the eponym function for the deformation object, as well as >ApplyDeformationsToHistoSensitivityImage() if data mode is histogram.
           Then reinitialize the temporary backup deformation images (the backward image, and the sensitivity image if data mode is histogram) 
  \return 0 if success, positive value otherwise
*/
int oDeformationManager::ApplyDeformationsToBackwardImage(oImageSpace* ap_Image)
{
  #ifdef CASTOR_DEBUG
  if (!m_initialized)
  {
    Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage() -> Called while not initialized !" << endl);
    Exit(EXIT_DEBUG);
  }
  #endif
  
  if (m_UseDeformationResp)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationsToBackwardImage-> Deformation of respiratory type, gate # " 
                           << mp_ID->GetCurrentRespGate(0)<< "." <<endl);
    if(mp_DeformationResp->ApplyDeformationsToBackwardImage(ap_Image, mp_ID->GetCurrentRespGate(0)) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation !" << endl);
      return 1;
    }
      
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM)
      if(mp_DeformationResp->ApplyDeformationsToHistoSensitivityImage(ap_Image, mp_ID->GetCurrentRespGate(0)) )
      {
        Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation of the sensitivity image !" << endl);
        return 1;
      }
  }
  
  if (m_UseDeformationCard)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationsToBackwardImage-> Deformation of cardiac type, gate # " 
                        << mp_ID->GetCurrentCardGate(0) << "." <<endl);
    if(mp_DeformationCard->ApplyDeformationsToBackwardImage(ap_Image, mp_ID->GetCurrentCardGate(0)) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation !" << endl);
      return 1;
    }
    
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM)
      if(mp_DeformationCard->ApplyDeformationsToHistoSensitivityImage(ap_Image, mp_ID->GetCurrentCardGate(0)) )
      {
        Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation of the sensitivity image !" << endl);
        return 1;
      }
  }
  
  if (m_UseDeformationInv)
  {
    if(m_verbose >=3) Cout("oDeformationManager::ApplyDeformationsToBackwardImage-> Deformation of involuntary motion type, gate # " 
                         << mp_ID->GetCurrentPMotionIndex(0) << "." <<endl);
    if( mp_DeformationInv->ApplyDeformationsToBackwardImage(ap_Image, mp_ID->GetCurrentPMotionIndex(0)) )
    {
      Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation !" << endl);
      return 1;
    }
    
    // Perform deformation of the sensitivity image ((PET) MODE_HISTOGRAM)
    if(m_dataMode == MODE_HISTOGRAM)
      if(mp_DeformationInv->ApplyDeformationsToHistoSensitivityImage(ap_Image, mp_ID->GetCurrentPMotionIndex(0)) )
      {
        Cerr("***** oDeformationManager::ApplyDeformationsToBackwardImage()-> An error occured while performing final backward image deformation of the sensitivity image !" << endl);
        return 1;
      }
  }
  
  // Reinitialize temporary deformation image(s)
  if (m_UseDeformationResp || m_UseDeformationCard || m_UseDeformationInv)
  {
    ap_Image->InitBwdImageForDeformation(); 
  
    if(m_dataMode == MODE_HISTOGRAM)
      ap_Image->InitSensImageForDeformation(); 
  }

  return 0;
}