NIREPDataManager.cxx

Go to the documentation of this file.

#include "NIREPDataManager.h"
#include "NIREPResourceDatabase.h"
#include "NIREPDefinitions.h"
#include <algorithm>
#include <cstdlib>
#include "Interface.h"
#include "gecSICLETransformation.h"
#include "gecAIRTransformation.h"

/* Constructor */
NIREPDataManager::NIREPDataManager(void)
{
  // Set data memory usage to zero
  //this->memoryUsage = 0;
}


/* Destructor */
NIREPDataManager::~NIREPDataManager(void)
{
  for(LoadedSpatialDataList::iterator entry=this->loadedSpatialDataList.begin();
        entry!=this->loadedSpatialDataList.end(); entry++)
    delete (entry->second).data;
  this->loadedSpatialDataList.clear();
  this->spatialDataResourceListTree.dataset.clear();
  this->transformationResourceList.clear();
}


void NIREPDataManager::SetLoadedSpatialDataListEntry(const std::string& dmid,
                                                     gec::SpatialData* data)
{
  // Add new entry if entry doesn't already exist.
  // Else, update existing data with new data
  LoadedSpatialData entry;
  entry.data = data; entry.refCount = 0;
  this->loadedSpatialDataList[dmid] = entry;
  mainPage->addDatabaseItem(dmid, data->GetVTKData()->GetActualMemorySize(), this->GetMemoryUsage());
}


gec::SpatialData* NIREPDataManager::GetLoadedSpatialDataListEntry(const std::string& dmid, DisplayDescription * displayDescription)
{
  LoadedSpatialDataList::iterator entry = this->loadedSpatialDataList.find(dmid);
  if(entry != this->loadedSpatialDataList.end()) {
    // Increment reference counter
    (entry->second).refCount++;
    return (entry->second).data;
  }
  // Did not find the requested data loaded in memory.  Now see if it is on disk.
  ResourceDescription * rdescrip;
  bool LoadOkay;

  // Check if data manager id is in the data description list.  If so then load.
  rdescrip = displayDescription->GetRDL()->GetDataDescrip(dmid);
  if (rdescrip != NULL){
    // Load data into loadedSpatialDataList
    LoadOkay = LoadSpatialData(dmid,displayDescription);
    if (LoadOkay){
      // Get spatial data from loadedSpatialDataList
      entry = this->loadedSpatialDataList.find(dmid);
      if(entry != this->loadedSpatialDataList.end()) {
        // Increment reference counter
        (entry->second).refCount++;
        return (entry->second).data;
      } else {
        wxString temp = wxT("ERROR - Unable to retrieve resource with given ID: ");
        temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
        wxLogError(temp);
        return NULL; // Error could not find data even though it was just inserted
      }
    } else {
      wxString temp = wxT("ERROR - Unable to load resource with given ID: ");
      temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
      wxLogError(temp);

      return NULL; // Error: Could not find loaded data
    }
  }

  // Check if data manager id is in the transformation description list.  If so then load.
  rdescrip = displayDescription->GetRDL()->GetTransformDescrip(dmid);
  if (rdescrip != NULL){
    // Load data into loadedSpatialDataList
    LoadOkay = LoadTransformation(dmid,displayDescription);
    if (LoadOkay){
      // Get spatial data from loadedSpatialDataList
      entry = this->loadedSpatialDataList.find(dmid);
      if(entry != this->loadedSpatialDataList.end()) {
        // Increment reference counter
        (entry->second).refCount++;
        return (entry->second).data;
      } else {
        wxString temp = wxT("ERROR - Unable to retrieve resource with given ID: ");
        temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
        wxLogError(temp);
        return NULL; // Error could not find data even though it was just inserted
      }
    } else {
      wxString temp = wxT("ERROR - Unable to load resource with given ID: ");
      temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
      wxLogError(temp);

      return NULL; // Error: Could not find loaded data
    }
  }

 
  // Return NULL so that the Evaluator Process can respond appropriately
  return NULL;

  /* Worry about memory management later
  // Check if entry is in flushMe queue and remove if present
  for(std::vector<std::string>::iterator iter = flushMe.begin();
        iter!=flushMe.end(); ++iter) {
    if(*iter == dataID) {
      flushMe.erase(iter);
    }
  }
  */

}

bool NIREPDataManager::LoadSpatialData(const std::string& datasetID,
                                       const std::string& dataID,
                                       DisplayDescription * displayDescription){

  const std::string dmid = EvalCmd["SpatialData"] + "(" + datasetID + "," + dataID + ")";
  return LoadSpatialData(dmid,displayDescription);
}

bool NIREPDataManager::LoadSpatialData(const std::string& dmid,
                                        DisplayDescription * displayDescription){

  ResourceDescription * rdescrip = displayDescription->GetRDL()->GetDataDescrip(dmid);

  if (rdescrip != NULL){
    gec::SpatialData *data = NULL;
    if (rdescrip->GetDataType().compare("image") == 0){
      data = new gec::Image(rdescrip->GetFilename("0"));
    } 
    else if (rdescrip->GetDataType().compare("objectmap") == 0){
      data = new gec::ObjectMap(rdescrip->GetFilename("0"));
    } 
    else if (rdescrip->GetDataType().compare("transformation") == 0){
      LoadTransformation(dmid,displayDescription);
    } 
    else {
      // Other SpatialData type support later
      wxLogError( _("Unsupported SpatialData type!") );
      return false;
    }
    this->SetLoadedSpatialDataListEntry(dmid, data);
    return true;
  } else {
    wxString temp = wxT("ERROR - The spatial data resource did not contain any entry with the given ID: ");
    temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
    wxLogError(temp);
    return false;
  }

}

bool NIREPDataManager::LoadTransformation(const std::string& source,
                                          const std::string& target,
                                          const std::string& transformation,
                                          DisplayDescription * displayDescription){

  const std::string dmid =
     EvalCmd["Transformation"] + "(" + source + "," + target + "," + transformation + ")";
  return LoadTransformation(dmid,displayDescription);
}

bool NIREPDataManager::LoadTransformation(const std::string& dmid,
                                          DisplayDescription * displayDescription){

  ResourceDescription * rdescrip = displayDescription->GetRDL()->GetTransformDescrip(dmid);

  if (rdescrip != NULL){
    gec::SpatialData* trans = NULL;
    if (rdescrip->GetFormat().compare("displacement") == 0){
      trans = new gec::Transformation(rdescrip->GetFilename("0"));
    } 
    else if (rdescrip->GetFormat().compare("displacement3") == 0){
      const std::string files[3] = {rdescrip->GetFilename("0"),
                                    rdescrip->GetFilename("1"),
                                    rdescrip->GetFilename("2")};
      trans = new gec::Transformation(&(files[0]));
    } 
    else if (rdescrip->GetFormat().compare("sicle_coeff") == 0){
      trans = new gec::SICLETransformation(rdescrip->GetFilename("0"));
    }
    else if (rdescrip->GetFormat().compare("air5") == 0){
      trans = new gec::AIRTransformation(rdescrip->GetFilename("0"));
    }
    else {
      // Other SpatialData type support later
      wxLogError( _("Unsupported Transformation type!") );
      return false;
    }
    // Scale all transformations to image space before saving them to the Loaded Spatial Data List
    if (rdescrip->GetTransformUnits().compare("unit_cube") == 0){
      dynamic_cast<gec::Transformation *>(trans)->Rescale(trans->GetDimension());
    }
    if (rdescrip->GetTransformUnits().compare("physical_space") == 0){
      double* spacing = trans->GetSpacing();
      double ispacing[] = {1.0/spacing[0], 1.0/spacing[1], 1.0/spacing[2]};
      dynamic_cast<gec::Transformation *>(trans)->Rescale(ispacing);
    }

    this->SetLoadedSpatialDataListEntry(dmid, trans);
    return true;
  } else {
    wxString temp = wxT("ERROR - Resource Description List did not contain entry with the given ID: ");
    temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
    wxLogError(temp);
    return false;
  }

}


bool NIREPDataManager::ReleaseLoadedSpatialDataListEntry(
                                               const std::string& dmid)
{
  LoadedSpatialDataList::iterator entry =
                                 this->loadedSpatialDataList.find(dmid);
  if(entry == this->loadedSpatialDataList.end()) {
    wxString temp = wxT("ERROR locating data entry with given ID: ");
    temp.Append(wxString::Format (wxT("%s"), dmid.c_str()));
    wxLogError(temp);
    return false;
  }

  // Decrement reference counter
  //if((entry->second).refCount > 0) {
  //  (entry->second).refCount--;
  //}

  



  /* Worry about memory management later
  // If refCount is zero, ready to be flushed out
  if((entry->second).refCount == 0) {
    this->flushMe.push((entry->first));
  }
  */

  delete entry->second.data;
  this->loadedSpatialDataList.erase(entry);

  mainPage->SetTotalMemoryUsage(this->GetMemoryUsage());

  return true;
}

unsigned long NIREPDataManager::GetMemoryUsage()
{
  LoadedSpatialDataList::iterator tempIter = this->loadedSpatialDataList.begin();
  unsigned long memoryUsage = 0;
  while(tempIter!=this->loadedSpatialDataList.end())
  { 
    //for(unsigned int i=0; i< tempIter->second.data->GetNumberOfData(); i++)
    //{
      memoryUsage = memoryUsage + tempIter->second.data->GetVTKData()->GetActualMemorySize();
    //}
    tempIter++;
  }
  return memoryUsage;
}