sScannerManager.cc

Go to the documentation of this file.

/*
  Implementation of class sScannerManager

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

#include "sScannerManager.hh"
#include "sAddonManager.hh"

// Singleton : set pointer to object to NULL
sScannerManager *sScannerManager::mp_Instance = NULL;

// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \brief sScannerManager constructor.
  \details It is private at this class is singleton. 
           This class should be instanciated using the GetInstance() function 
           Initialize the member variables to their default values.
*/
sScannerManager::sScannerManager()
{
  mp_Scanner = NULL;
  m_verbose = -1;
  m_pathToScannerFile = "";
  m_scannerName = "";
  m_hasUserScannerFile = false;
  m_hasGenericScannerFile = false;
  m_allParametersChecked = false;
  m_saveLUTFlag = false;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \brief sScannerManager destructor. 
*/
sScannerManager::~sScannerManager()
{
  if(mp_Scanner != NULL) delete mp_Scanner;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn CheckParameters
  \brief Check if all parameters have been correctly initialized, and call the CheckParameters function of the scanner object
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::CheckParameters()
{
  if (m_verbose>=2) Cout("sScannerManager::CheckParameters ..."<< endl); 
    
  if (mp_Scanner == NULL)
  {
     Cerr("***** sScannerManager::CheckParameters() -> Scanner object not initialized" << endl);
     return 1;
  }
  
  if (m_hasUserScannerFile == false && m_hasGenericScannerFile == false)
  {
     Cerr("***** sScannerManager::CheckParameters() -> Scanner file type (generic or user provided) not initialized" << endl);
     return 1;
  }

  if (m_scannerName.empty())
  {
     Cerr("***** sScannerManager::CheckParameters() -> Scanner name not initialized" << endl);
     return 1;
  }

  if (m_pathToScannerFile.empty())
  {
     Cerr("***** sScannerManager::CheckParameters() -> Path to scanner file not initialized" << endl);
     return 1;
  }
  
  if (m_verbose<0)
  {
     Cerr("***** sScannerManager::CheckParameters() -> Verbosity level not initialized" << endl);
     return 1;
  }
  
  // Check parameters of the scanner object
  if (mp_Scanner->CheckParameters())
  {
    Cerr("***** sScannerManager::BuildScannerObject() -> A problem occurred while checking Scanner Object parameters !" << endl);
    return 1;
  }
  
  m_allParametersChecked = true;
  
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn Initialize
  \brief Initialization :
         - check if all parameters of the manager have been checked
         - call the initialization function of the scanner object 
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::Initialize()
{
  if(m_verbose>=2) Cout("sScannerManager::Initialize ..."<< endl); 
    
  if(m_allParametersChecked == false)
  {
     Cerr("***** sScannerManager::Initialize() -> Parameters have not been checked !" << endl);
     return 1;
  }

  // Initialize the scanner object
  if(mp_Scanner->Initialize())
  {
    Cerr("***** sScannerManager::BuildScannerObject() -> A problem occurred while initializing Scanner Object !" << endl);
    return 1;
  }

  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn ShowScannersDescription
  \brief Get the description associated to the different scanners and print all on screen.
         Walk through the scanner repository and look for the keyword "description" in .geom file and .hscan file.
  \return 0 if success, positive value otherwise
  \todo Check everything output correctly for all implemented scanners
*/
int sScannerManager::ShowScannersDescription()
{
  if(m_verbose>=3) Cout("sScannerManager::ShowScannersDescription ..."<< endl); 
    
  // Return when using MPI and mpi_rank is not 0
  #ifdef CASTOR_MPI
  int mpi_rank = 0;
  MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
  if (mpi_rank!=0) return 0;
  #endif
  
  // Gather all the available scanner from the repository
  vector<string> list_scanner_names;
  if(GetAvailableScanners(&list_scanner_names))
  {
    Cerr("***** sScannerManager::ShowScannersDescription() -> a problem occurred when recovering scanner names from the scanner repository !" << endl);
    return 1;
  }
  
  cout << endl << "Here is the list of all available scanners in the repository along with their options:" << endl << endl;
  for (unsigned int iter = 0; iter!=list_scanner_names.size(); iter++)
  {
    // Get the actual scanner in temporary local variable
    string scanner_file = sOutputManager::GetInstance()->GetPathToConfigDir() + "scanner" + OS_SEP;
    // Print out the name of this scanner
    cout << "------------------------------------------------------------------" << endl;
    cout << "-----  \"" << list_scanner_names[iter] << "\"" << endl;
    cout << "------------------------------------------------------------------" << endl;
    // Proceed
    scanner_file.append(list_scanner_names[iter]);
    // look for the "description" keyword in the .geom or .hscan file
    string description;

    ReadDataASCIIFile(scanner_file, "description", &description, 1, 1);
    // look for the "description" keyword in the .geom or .hscan file
    cout << description << endl << endl;
  }
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn FindScannerSystem
  \param a_scannerName : string containing name of the required scanner
  \brief Look for a file matching with the scanner name in parameter inside the scanner repository 
  \return 0 if success (scanner found). Positive value otherwise
*/
int sScannerManager::FindScannerSystem(string a_scannerName)
{
  if (m_verbose>=3) Cout("sScannerManager::FindScannerSystem() -> Search the scanner of data file in the configuration directory"<< endl); 
    
  if (a_scannerName.empty())
  {
    Cerr("***** sScannerManager::FindScannerSystem() -> scanner name is empty !" << endl);
    return 1;
  }
  else
  {
    // Get the list of scanner from the repository
    vector<string> repository_scanner_names;
    if(GetAvailableScanners(&repository_scanner_names))
    {
      Cerr("***** sScannerManager::FindScannerSystem() -> a problem occurred when recovering scanner names from the scanner repository !" << endl);
      return 1;
    }
  
    m_scannerName = a_scannerName;
    m_pathToScannerFile = sOutputManager::GetInstance()->GetPathToConfigDir() + "scanner" + OS_SEP;
    
    // String to recover generic/user-made scanner file
    string generic_scanner_file, user_scanner_file;
    
    // Loop over the scanner available in the repository, and check if the scanner name match with any of these
    for (unsigned int index_name=0 ; index_name<repository_scanner_names.size() ; index_name++)
    {
      string gfile = a_scannerName;
      string ufile = a_scannerName;

      // Check if the scanner match a geom file (generic_scanner_file)
      if (gfile.append(".geom") == repository_scanner_names[index_name])
      {
        generic_scanner_file = a_scannerName;
        generic_scanner_file.append(".geom");
        m_hasGenericScannerFile = true;
        
        if(m_verbose >= 3) Cout("sScannerManager::FindScannerSystem() -> matched generic file for the scanner system: " << repository_scanner_names[index_name] << endl);
      }
      
      // Check if the scanner match an user file (user provided LUT)
      if (ufile.append(".hscan") == repository_scanner_names[index_name])
      {
        user_scanner_file = a_scannerName;
        user_scanner_file.append(".hscan");
        m_hasUserScannerFile = true;
 
        if(m_verbose >= 3) Cout("sScannerManager::FindScannerSystem() -> matched custom LUT for the scanner system: " << repository_scanner_names[index_name] << endl);
      }

    }
    
    // Both a generic file and user-provided LUT exist for this system.
    // Generic file selected by default
    if(m_hasGenericScannerFile == true && m_hasUserScannerFile == true)
    {
      if(m_verbose >= 3)
      {
        Cerr("***** WARNING sScannerManager::FindScannerSystem() -> Both a generic file and user-provided LUT have been detected for the " << a_scannerName << " system." << endl);
        Cerr("                                                      The generic file (*.geom) will be selected by default." << endl);
      }
     
      m_hasUserScannerFile = false;
    }
    
    // Initialize m_pathToScannerFile member variable
    if(m_hasGenericScannerFile == true)
      m_pathToScannerFile.append(generic_scanner_file.c_str());
    else if(m_hasUserScannerFile == true)
      m_pathToScannerFile.append(user_scanner_file.c_str());
    else // Unknown scanner, output scanner description and throw error
    {
      Cerr("***** sScannerManager::FindScannerSystem() -> Scanner '"<< a_scannerName << 
           "' is not known in the scanner repository. Please provide a LUT/generic file for this scanner in the scanner repository in: " << 
           sOutputManager::GetInstance()->GetPathToConfigDir() << "scanner" << OS_SEP << endl << endl;);
      
      ShowScannersDescription();
      
      return 1;
    }
    
    return 0;
  }
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn BuildScannerObject()
  \brief Instantiate the specific scanner object related to the modality, and set verbosity of scanner object
  \todo delete the check on modality once all scanner classes will be completely implemented ? 
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::BuildScannerObject()
{
  if(m_verbose>=2) Cout("sScannerManager::BuildScannerObject ..."<< endl); 
    
  // Check scanner modality
  string scanner_type;
  
  typedef vScanner *(*maker_scanner) ();

  // Get the system type from the value of the modality field inside the scanner header
  if (ReadDataASCIIFile(m_pathToScannerFile, "modality", &scanner_type, 1, KEYWORD_MANDATORY) == 1)
  {
    Cerr("***** sScannerManager::BuildScannerObject() -> 'Modality' field not found in the header of the scanner configuration file at :"<< endl);
    Cerr("*****                                          "<<m_pathToScannerFile << endl);
    return 1;
  }
      
  // Get scanner's list from addon manager
  std::map <string,maker_scanner> list = sAddonManager::GetInstance()->mp_listOfScannerTypes;

  // Instanciate the scanner class corresponding to the modality
  // Throw error if no match
  if (list[scanner_type]) mp_Scanner = list[scanner_type]();
  else
  {
    Cerr("***** sScannerManager::BuildScannerObject() -> Modality '" << scanner_type << "' is unknown !" << endl);
    sAddonManager::GetInstance()->ShowHelpScanner();
    return 1;
  }

  // Set scanner verbosity
  mp_Scanner->SetVerbose(m_verbose);

  return 0;
}




// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn GetGeometricInfoFromDatafile
  \param a_path : string containing the path to datafile header
  \brief Call the specialized function of the scanner object in order to 
         get geometric informations from the datafile header
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::GetGeometricInfoFromDatafile(string a_path)
{
  if(m_verbose>=2) Cout("sScannerManager::GetGeometricInfoFromDatafile ..."<< endl); 
    
  if (mp_Scanner->GetGeometricInfoFromDatafile(a_path))
  {
    Cerr("***** sScannerManager::GetGeometricInfoFromDatafile() -> An error occurred while getting information from the datafile." << endl);          
    return 1;
  }

  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn InstantiateScanner
  \brief Instantiate scanner using the related function in the scanner classes
  \todo delete the check on scanner type once all scanner classes will be completely implemented. 
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::InstantiateScanner()
{
  if(m_verbose>=2) Cout("sScannerManager::InstantiateScanner ..."<< endl); 
  
  // Check if the scanner object is known (TODO : delete this check once all scanner classes will be completely implemented)
  if (mp_Scanner->GetScannerType() < 0)
  {
    Cerr("***** sScannerManager::BuildScannerObject() -> Unknow scanner type !" << endl);
    return 1;
  }

  // Instantiate geometry
  if (mp_Scanner->Instantiate(m_hasUserScannerFile))
  {
    Cerr("***** sScannerManager::InstantiateScanner() -> An error occurred while instanciating the Scanner object !" << endl);
    return 1;
  }

  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn BuildLUT()
  \brief Call the eponym function of the scanner class
  \return 0 if success. Positive value otherwise
*/
int sScannerManager::BuildLUT()
{
  if(m_verbose>=2) Cout("sScannerManager::Generate the geometric Look-Up Table ..."<< endl); 
    
  // Generate LUT
  if (mp_Scanner->BuildLUT(m_hasUserScannerFile))
  {
    Cerr("***** sScannerManager::BuildLUT() -> A problem occurred while generating/reading the LUT ." << endl);          
    return 1;
  }

  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn GetAvailableScanners
  \param ap_scannerNames : vector list of string to recover the available scanner names
  \brief Gather all the names of the header files (.geom & .hscan) 
         in the repository folder in the vector<string> passed in parameter
  \return 0 if sucess, positive value otherwise
*/
int sScannerManager::GetAvailableScanners(vector<string> *ap_scannerNames)
{
  if(m_verbose>=3) Cout("sScannerManager::GetAvailableScanners ..."<< endl); 
    
  DIR *respository_dir;
  struct dirent *ent;
  
  string str_geom(".geom"), str_hscan(".hscan");
  string scanner_repository = sOutputManager::GetInstance()->GetPathToConfigDir() + "scanner" + OS_SEP;
  
  if ((respository_dir = opendir(scanner_repository.c_str())) != NULL) 
  {
    // print all the files and directories within the repository directory
    while ((ent = readdir (respository_dir)) != NULL) 
    {
      string scanner_name = ent->d_name;
      
      if(scanner_name.at(scanner_name.size()-1) != '~') // Get rid of backup files in linux.
      
      // .geom or .hscan file found
      if(scanner_name.find(str_geom)!=string::npos || scanner_name.find(str_hscan)!=string::npos )
      {
        ap_scannerNames->push_back(scanner_name);
      }
    }
    closedir (respository_dir);
  } 
  else 
  {
    Cerr("***** sScannerManager::GetAvailableScanners() -> could not open the repository directory at: " << scanner_repository << endl);
    return 1;
  }

  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn GetScannerLayerNbRings
  \param a_layer : layer index
  \brief Ask the number of rings to the scanner object for a specific layer. 
         Returns an error if this information is not available for the scanner type of the object (eg : SPECT systems) 
  \return The number of rings in the system if success. NEGATIVE value otherwise
*/
int sScannerManager::GetScannerLayerNbRings(int a_layer)
{
  if(m_verbose>=3) Cout("sScannerManager::GetScannerLayerNbRings ..."<< endl); 
    
  if(mp_Scanner->GetScannerType() == SCANNER_PET) 
  {
    int nb_rings = mp_Scanner->GetScannerLayerNbRings(a_layer);
    
    // Check for error
    if (nb_rings <= 0)
    {
      Cerr("***** sScannerManager::GetScannerLayerNbRings() -> error when trying to get the number of rings in the system for the crystal layer " << a_layer+1 << " !" << endl);
      return -1;
    }
    else 
      return nb_rings;
  }
  else
  {
    Cerr("***** sScannerManager::GetScannerLayerNbRings() -> This function is only available for PET scans !" << endl);
    return -1;
  }
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_GetModalityStopValueMainLoop
  \brief Get the stop value for the main loop of analytic projection depending on the modality 
  \return the required stop value if success, NEGATIVE value otherwise
  \todo Cases for CT and sinogram scanner types
*/
int64_t sScannerManager::PROJ_GetModalityStopValueMainLoop()
{
  if(m_verbose>=3) Cout("sScannerManager::PROJ_GetModalityStopValueMainLoop ..."<< endl); 
  
  if (mp_Scanner->GetScannerType() == SCANNER_PET)
  {
    return mp_Scanner->GetSystemNbElts();
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SPECT_PINHOLE ||
          mp_Scanner->GetScannerType() == SCANNER_SPECT_CONVERGENT )
  {
    return (int64_t)mp_Scanner->PROJ_GetSPECTNbProjections(); // cast from uint16_t to int
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_CT)
  {
    // TODO
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Not implemented for CT yet!" << endl);
    return -1;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SINOGRAM)
  {
    // TODO + should call a GetType() like function for scanner defined as a sinogram
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Not implemented for Sinogram scanner yet!" << endl);
    return -1;
  }
  else
  {
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Unknown scanner type!" << endl);
    return -1;
  }
  
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_GetModalityStartValueInnerLoop
  \param a_elt1 : Current nb of processed crystals (PET), projections (SPECT)
  \brief Get the start value for the inner loop of analytic projection depending on the modality 
  \return the required stop value if success, NEGATIVE value otherwise
  \todo Cases for CT and sinogram scanner types
  \todo Precise with SS on which index SPECT inner loop should be done
*/
int64_t sScannerManager::PROJ_GetModalityStartValueInnerLoop(int64_t a_elt1)
{  
  #ifdef CASTOR_VERBOSE
  if(m_verbose>=4) Cout("sScannerManager::PROJ_GetModalityStopValueMainLoop ..."<< endl); 
  #endif
  
  if (mp_Scanner->GetScannerType() == SCANNER_PET)
  {
    return a_elt1+1;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SPECT_PINHOLE ||
          mp_Scanner->GetScannerType() == SCANNER_SPECT_CONVERGENT )
  {
    return 0; // (first crystal)
    // TODO SS: here the inner loop should be done on the number of views
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_CT)
  {
    // TODO
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Not implemented for CT yet!" << endl);
    return -1;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SINOGRAM)
  {
    // TODO + should call a GetType() like function for scanner defined as a sinogram
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Not implemented for Sinogram scanner yet!" << endl);
    return -1;
  }
  else
  {
    Cerr("sScannerManager::PROJ_GetModalityStopValueMainLoop()-> Unknown scanner type!" << endl);
    return -1;
  }
  
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_GetCurrentProgression
  \param a_elt1 : Current nb of processed #1 crystals (PET), projections (SPECT)
  \param a_elt2 : Current nb of processed #2 crystals (PET), crystals (SPECT)
  \param ap_nbEltsArray : Total number of elements processed for each #1 crystals (PET/CT systems) 
  \param a_nbRGates
  \param a_nbCGates
  \param a_fr
  \param a_rg
  \param a_cg
  \brief Get numerator value according to the modality to compute percent progression during the analytical projection process
  \return the required progression value if success, negative value otherwise
  \todo Cases for CT and sinogram scanner types
  \todo Optimize this, for now it's quite a lot of operation for each couple of elements
  \todo Check everything is ok for 3D/4D PET and SPECT 
*/
int64_t sScannerManager::PROJ_GetCurrentProgression(int64_t a_elt1, int64_t a_elt2, int64_t* ap_nbEltsArray, 
                                                     int a_nbRGates, int a_nbCGates,
                                                     int a_fr, int a_rg, int a_cg)
{
  #ifdef CASTOR_VERBOSE
  if(m_verbose>=4) Cout("sScannerManager::PROJ_GetCurrentProgression ..."<< endl); 
  #endif
  
  // TODO : optimization, maybe too much operations for each couple of elements
  if (mp_Scanner->GetScannerType() == SCANNER_PET)
  {
    int64_t nb_total_elts = mp_Scanner->GetSystemNbElts();

    return ap_nbEltsArray[a_elt1]+a_elt2+1 + 
           (int64_t)(a_fr*a_nbRGates*a_nbCGates + a_rg*a_nbCGates + a_cg)* nb_total_elts*nb_total_elts/2;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SPECT_PINHOLE ||
          mp_Scanner->GetScannerType() == SCANNER_SPECT_CONVERGENT )
  {
    return a_elt2 + a_elt1*mp_Scanner->GetSystemNbElts() + 
           a_fr * a_nbRGates * a_nbCGates * mp_Scanner->GetSystemNbElts() +
           a_rg * a_nbCGates * mp_Scanner->GetSystemNbElts() +
           a_cg * mp_Scanner->GetSystemNbElts();
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_CT)
  {
    //TODO
    Cerr("sScannerManager::PROJ_GetCurrentProgression()-> Not implemented for CT yet!" << endl);
    return -1;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SINOGRAM)
  {
    //TODO + should call a GetType() like function for scanner defined as a sinogram
    Cerr("sScannerManager::PROJ_GetCurrentProgression()-> Not implemented for Sinogram scanner yet!" << endl);
    return -1;
  }
  else
  {
    Cerr("sScannerManager::PROJ_GetCurrentProgression()-> Unknown scanner type!" << endl);
    return -1;
  }
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_GetProgressionFinalValue
  \brief Get numerator value according to the modality to compute percent progression during the projection process
  \return the required progression value if success, negative value otherwise
  \todo Cases for CT and sinogram scanner types
*/
int64_t sScannerManager::PROJ_GetProgressionFinalValue()
{
  if(m_verbose>=3) Cout("sScannerManager::PROJ_GetProgressionFinalValue ..."<< endl); 
  
  if (mp_Scanner->GetScannerType() == SCANNER_PET)
  {
    //return mp_Scanner->GetSystemNbElts();
    int64_t nb_total_elts = mp_Scanner->GetSystemNbElts();
    return nb_total_elts*nb_total_elts/2;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SPECT_PINHOLE ||
          mp_Scanner->GetScannerType() == SCANNER_SPECT_CONVERGENT )
  {
    return (int64_t)mp_Scanner->PROJ_GetSPECTNbProjections()*mp_Scanner->GetSystemNbElts(); // cast from uint16_t to int
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_CT)
  {
    //TODO
    Cerr("sScannerManager::PROJ_GetProgressionFinalValue()-> Not implemented for CT yet!" << endl);
    return -1;
  }
  else if(mp_Scanner->GetScannerType() == SCANNER_SINOGRAM)
  {
    //TODO + should call a GetType() like function for scanner defined as a sinogram
    Cerr("sScannerManager::PROJ_GetProgressionFinalValue()-> Not implemented for Sinogram scanner yet!" << endl);
    return -1;
  }
  else
  {
    Cerr("sScannerManager::PROJ_GetProgressionFinalValue()-> Unknown scanner type!" << endl);
    return -1;
  }
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_SetPETSpecificParameters (Analytic Projection)
  \param a_maxRingDiff : max number of axial ring difference
  \brief Deliver to the PET scanner object all informations provided from the datafile header
  \return 0 if success, positive value otherwise
  \todo How to handle systems with several layer of rings ?
*/
int sScannerManager::PROJ_SetPETSpecificParameters(int a_maxRingDiff)
{
  if(m_verbose>=3) Cout("sScannerManager::PROJ_SetPETSpecificParameters ..."<< endl); 
  
  if (mp_Scanner->GetScannerType() != SCANNER_PET)
  {
    Cerr("***** sScannerManager::SetPETSpecificParameters() -> The scanner object is not of PET type !" << endl);
    return 1;
  }
  else
  {
    mp_Scanner->SetPETMaxRingDiff(a_maxRingDiff);
  }
  
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
int sScannerManager::PROJ_GetPETSpecificParameters(int* ap_maxRingDiff)
{
  if(m_verbose>=3) Cout("sScannerManager::PROJ_GetPETSpecificParameters ..."<< endl); 
    
  if (mp_Scanner->GetScannerType() != SCANNER_PET )
  {
    Cerr("***** sScannerManager::PROJ_GetPETSpecificParameters()-> The scanner object is not of PET type !" << endl);
    return 1;
  }
  else
  {
    int max_ring_diff = -1;
    
    if (mp_Scanner->PROJ_GetPETSpecificParameters(&max_ring_diff) )
    {
      Cerr("***** sScannerManager::PROJ_GetPETSpecificParameters()-> A problem occurred while retrieving PET parameters from the scanner object !" << endl);
      return 1;
    }
    
    if (max_ring_diff < 0)
    {
      Cerr("***** sScannerManager::PROJ_GetPETSpecificParameters()-> max ring difference should be > 0 !" << endl);
      return 1;
    }
    else
      *ap_maxRingDiff = max_ring_diff;
  }
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn PROJ_SetSPECTSpecificParameters (Analytic Projection)
  \param ap_nbOfBins : 2 elements array containing transaxial number of bins
  \param a_nbOfProjections : number of views/projections
  \param a_firstAngle : angle of the first view
  \param a_lastAngle : angle of the last view
  \param ap_projectionAngles : an array containing angles for each view
  \param a_CORtoDetectorDistance : a distance between the center of rotation and the detector
  \param a_RotDirection : Rotation direction of the head (clockwise/counter-clockwise)
  \brief Deliver to the SPECT scanner object all informations provided from the acquisition parameters
  \details For analytical projection, this data is provided from the command-line options 
  \return 0 if success, positive value otherwise
*/
int sScannerManager::PROJ_SetSPECTSpecificParameters(uint16_t* ap_nbOfBins, 
                                                     uint32_t a_nbOfProjections, 
                                                     FLTNB a_firstAngle, 
                                                     FLTNB a_stepAngle, 
                                                     FLTNB* ap_projectionAngles, 
                                                     FLTNB a_CORtoDetectorDistance,
                                                     string a_rotDirection)
{
  if(m_verbose>=3) Cout("sScannerManager::PROJ_SetSPECTSpecificParameters ..."<< endl); 
    
  // Return error if wrong modality
  if (mp_Scanner->GetScannerType() != SCANNER_SPECT_CONVERGENT && mp_Scanner->GetScannerType() != SCANNER_SPECT_PINHOLE)
  {
    Cerr("***** sScannerManager::SetPETSpecificParameters()-> The scanner object is not of PET type !" << endl);
    return 1;
  }
  else
  {
    // Nb bins
    mp_Scanner->PROJ_SetSPECTNbBins(ap_nbOfBins);
    
    // Nb projections
    if(a_nbOfProjections == 0)
    {
      Cerr("***** sScannerManager::SetSPECTSpecificParameters()-> Error, SPECT analytic projection requires an user-specified number of projections !" << endl);
      return 1;
    }
    
    mp_Scanner->PROJ_SetSPECTNbProjections(a_nbOfProjections);


    // Projection angles initialized with either each angles, or calculated from first/last angle
    // By default, we chose the user-provided custom initialization for SPECT projection angles
    // If not initialized, we computed them from first/last angle
    if(ap_projectionAngles == NULL)
    {
      // If no custom initialization have been provided, then we check if we have first and last angles values for automatic initialization of the projection angles
      if(a_firstAngle<0 || a_stepAngle<0)
      {
        Cerr("***** sScannerManager::SetSPECTSpecificParameters()-> Error, SPECT projection requires to set the projection angles using either the '-SPECT_ang' or '-SPECT_c_ang' options !" << endl);
        return 1;
      }
      else
      {
        // Fill the SPECT_projection_angles array
        ap_projectionAngles = new FLTNB[a_nbOfProjections];
        ap_projectionAngles[0] = a_firstAngle;
        
        for(uint32_t a=1 ; a<a_nbOfProjections ; a++)
          ap_projectionAngles[a] = ap_projectionAngles[a-1] + a_stepAngle;
      }
    }
    
    if(mp_Scanner->PROJ_SetSPECTAngles(ap_projectionAngles) )
    {
      Cerr("***** sScannerManager::SetSPECTAngles() -> An error occured while trying to initialize SPECT projection angles !" << endl);
      return 1;
    }

    // CORtoDetectorDistance
    if(mp_Scanner->PROJ_SetSPECTCORtoDetectorDistance(a_CORtoDetectorDistance) )
    {
      Cerr("***** sScannerManager::SetPETSpecificParameters() -> An error occured while trying to initialize SPECT distance between center of rotation to detectors !" << endl);
      return 1;
    }
    
    // Nb bins
    mp_Scanner->PROJ_SetSPECTRotDirection(a_rotDirection);
  }
  
  return 0;
}



// =====================================================================
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// =====================================================================
/*
  \fn GetSPECTSpecificParameters (Reconstruction)
  \param ap_nbOfProjections : number of views/projections
  \param ap_nbHeads : number of heads in the SPECT system
  \param ap_nbOfBins : 2 elements array containing transaxial number of bins
  \param ap_pixSizeXY : 2 elements array containing transaxial/axial pixel sizes
  \param ap_angles : an array containing angles for each view
  \param ap_CORtoDetectorDistance : a distance between the center of rotation and the detector  
  \param ap_headRotDirection : head rotation direction
  \brief Transfer geometric information recovered from the datafile to the scanner object
  \return 0 if success, positive value otherwise
*/
int sScannerManager::GetSPECTSpecificParameters(uint16_t* ap_nbOfProjections, 
                                                uint16_t* ap_nbHeads, 
                                                uint16_t* ap_nbOfBins, 
                                                FLTNB* ap_pixSizeXY,
                                                FLTNB*& ap_angles, 
                                                FLTNB*& ap_CORtoDetectorDistance,
                                                int* ap_headRotDirection)
{
  if(m_verbose>=3) Cout("sScannerManager::GetSPECTSpecificParameters ..."<< endl); 
    
  // Check modality
  if (mp_Scanner->GetScannerType() != SCANNER_SPECT_CONVERGENT && mp_Scanner->GetScannerType() != SCANNER_SPECT_PINHOLE)
  {
    Cerr("***** sScannerManager::PROJ_GetSPECTSpecificParameters()-> The scanner object is not of PET type !" << endl);
    return 1;
  }
  else
  {
    if (mp_Scanner->GetSPECTSpecificParameters(ap_nbOfProjections, ap_nbHeads, ap_nbOfBins, ap_pixSizeXY, ap_angles, ap_CORtoDetectorDistance, ap_headRotDirection) )
    {
      Cerr("***** sScannerManager::PROJ_GetSPECTSpecificParameters()-> A problem occurred while retrieving SPECT parameters from the scanner object !" << endl);
      return 1;
    }
    
  }
  return 0;
}