DicomFileMgr Class Reference

#include <Doxymodules_medical.h>

Public Member Functions
	~DicomFileMgr ()
std::vector< DicomFileStructure * >	GetStructFiles () const
void	SetCompression (G4String fComp)
void	AddFile (G4String fComp)
void	AddMaterial (std::vector< G4String > data)
void	AddMaterialDensity (std::vector< G4String > data)
void	AddCT2Density (std::vector< G4String > data)
void	Convert (G4String fFileName)
void	CheckNColumns (std::vector< G4String > wl, size_t vsizeTh)
void	ProcessFiles ()
void	CheckCTSlices ()
G4double	Hounsfield2density (Uint32 Hval)
size_t	GetMaterialIndex (G4double Hval)
size_t	GetMaterialIndexByDensity (G4double density)
void	BuildCTMaterials ()
void	MergeCTFiles ()
void	CheckPETSlices ()
void	BuildPETActivities ()
void	MergePETFiles ()
void	DumpToTextFile ()
void	SetStructureNCheck (G4int nsc)
G4int	GetStructureNCheck () const
void	SetStructureNMaxROI (G4int nsc)
G4int	GetStructureNMaxROI () const
G4int	GetCompression () const
G4String	GetFileOutName () const
void	SetControlPointMetersets ()
G4bool	IsMaterialsDensity () const

Static Public Member Functions
static DicomFileMgr *	GetInstance ()

Public Attributes
G4bool	bMaterialsDensity

Static Public Attributes
static G4int	verbose = 1

Protected Attributes
G4int	fCompression

Private Member Functions
	DicomFileMgr ()

Private Attributes
G4String	theFileOutName
mdct	theCTFiles
std::vector< DicomFileStructure * >	theStructFiles
std::vector< DicomFilePlan * >	thePlanFiles
mdpet	thePETFiles
std::map< G4double, G4String >	theMaterials
std::map< G4double, G4String >	theMaterialsDensity
std::map< G4int, G4double >	theCT2Density
DicomFileCT *	theCTFileAll
DicomFilePET *	thePETFileAll
G4int	theStructureNCheck
G4int	theStructureNMaxROI

Static Private Attributes
static DicomFileMgr *	theInstance = 0

Detailed Description

Definition at line 50 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

~DicomFileMgr()

DicomFileMgr::~DicomFileMgr ( )

inline

Definition at line 50 of file DicomFileMgr.hh.

{};

DicomFileMgr()

DicomFileMgr::DicomFileMgr ( )

private

Definition at line 50 of file DicomFileMgr.cc.

{
  fCompression = 1.;
  theCTFileAll = 0;
  theStructureNCheck = 4;
  theStructureNMaxROI = 100;
}

Member Function Documentation

GetInstance()

DicomFileMgr * DicomFileMgr::GetInstance ( )

static

Definition at line 41 of file DicomFileMgr.cc.

{
  if( !theInstance ) {
    theInstance = new DicomFileMgr;
  }
  return theInstance;
}

GetStructFiles()

std::vector< DicomFileStructure * > DicomFileMgr::GetStructFiles ( ) const

inline

Definition at line 56 of file DicomFileMgr.hh.

                                                        {
    return theStructFiles;
  }

SetCompression()

void DicomFileMgr::SetCompression

(

G4String

fComp

)

Definition at line 122 of file DicomFileMgr.cc.

{
  fCompression = G4UIcommand::ConvertToDouble(fComp);
}

AddFile()

void DicomFileMgr::AddFile

(

G4String

fComp

)

Definition at line 128 of file DicomFileMgr.cc.

{
  DcmFileFormat dfile;
  if( ! (dfile.loadFile(fileName.c_str())).good() ) {
    G4Exception("DicomHandler::ReadFile",
                "dfile.loadFile",
                FatalErrorInArgument,
                ("Error reading file " + fileName).c_str());
  }
  DcmDataset* dset = dfile.getDataset();
 
  OFString dModality;
  if( !dset->findAndGetOFString(DCM_Modality,dModality).good() ) {
    G4Exception("DicomHandler::ReadData ",
                "",
                FatalException,
                " Have not read Modality");
  }
  
  if( dModality == "CT" ) {
    DicomFileCT* df = new DicomFileCT(dset);
    df->ReadData();
    df->SetFileName( fileName );
    // reorder by location
    theCTFiles[df->GetMaxZ()] = df;
  } else if( dModality == "RTSTRUCT" ) {     
    DicomFileStructure* df = new DicomFileStructure(dset);
    df->ReadData();
    df->SetFileName( fileName );
    //    theFiles.insert(msd::value_type(dModality,df));
    theStructFiles.push_back(df);
  } else if( dModality == "RTPLAN" ) {     
    DicomFilePlan* df = new DicomFilePlan(dset);
    df->ReadData();
    df->SetFileName( fileName );
    //    theFiles.insert(msd::value_type(dModality,df));
    thePlanFiles.push_back(df);
  } else if( dModality == "PT" ) {     
    DicomFilePET* df = new DicomFilePET(dset);
    df->ReadData();
    df->SetFileName( fileName );
    //    theFiles.insert(msd::value_type(dModality,df));
    thePETFiles[df->GetMaxZ()] = df;
    //    thePETFiles.push_back(df);
  } else {
    G4Exception("DicomFileMgr::AddFIle()",
                "DFM001",
                FatalErrorInArgument,
                (G4String("File is not of type CT or RTSTRUCT or RTPLAN, but: ") 
                 + dModality).c_str());
  }
 
}

AddMaterial()

void DicomFileMgr::AddMaterial

(

std::vector< G4String >

data

)

Definition at line 183 of file DicomFileMgr.cc.

{
  if( theMaterials.size() > 0 && bMaterialsDensity ) {
    G4Exception("DicomFileMgr::AddMaterial",
                "DFM005",
                FatalException,
        "Trying to add a Material with :MATE and another with :MATE_DENS, check your input file");
  }
  bMaterialsDensity = false;
  theMaterials[G4UIcommand::ConvertToDouble(wl[2])] = wl[1];
}

AddMaterialDensity()

void DicomFileMgr::AddMaterialDensity

(

std::vector< G4String >

data

)

Definition at line 196 of file DicomFileMgr.cc.

{
  if( theMaterialsDensity.size() > 0 && !bMaterialsDensity ) {
    G4Exception("DicomFileMgr::AddMaterial",
                "DFM005",
                FatalException,
        "Trying to add a Material with :MATE and another with :MATE_DENS, check your input file");
  }
  bMaterialsDensity = true;
  theMaterialsDensity[G4UIcommand::ConvertToDouble(wl[2])] = wl[1];
}

AddCT2Density()

void DicomFileMgr::AddCT2Density

(

std::vector< G4String >

data

)

Definition at line 209 of file DicomFileMgr.cc.

{
  theCT2Density[G4UIcommand::ConvertToInt(wl[1])] = G4UIcommand::ConvertToDouble(wl[2]);
  G4cout << this << " AddCT2density " << theCT2Density.size() << G4endl;//GDEB
 
}

Convert()

void DicomFileMgr::Convert

(

G4String

fFileName

)

Definition at line 59 of file DicomFileMgr.cc.

{
  G4tgrFileIn fin = G4tgrFileIn::GetInstance(fileName);
  std::vector<G4String> wl; 
  // Read each file in file list
  theFileOutName = "test.g4dcm";
  int ii;
  for( ii = 0;; ii++) {
    if( ! fin.GetWordsInLine(wl) ) break;
    if( wl[0] == ":COMPRESSION" ) {
      CheckNColumns(wl,2);
      SetCompression(wl[1]);
    } else if( wl[0] == ":FILE" ) {
      CheckNColumns(wl,2);
      G4cout << "@@@@@@@ Reading FILE: " << wl[1]  << G4endl;
      AddFile(wl[1]);
    } else if( wl[0] == ":FILE_OUT" ) {
      CheckNColumns(wl,2);
      theFileOutName = wl[1];
    } else if( wl[0] == ":MATE_DENS" ) {
      CheckNColumns(wl,3);
      AddMaterialDensity(wl);
    } else if( wl[0] == ":MATE" ) {
      CheckNColumns(wl,3);
      AddMaterial(wl);
    } else if( wl[0] == ":CT2D" ) {
      CheckNColumns(wl,3);
      AddCT2Density(wl);
    } else {      
      G4Exception("DICOM2G4",
                  "Wrong argument",
                  FatalErrorInArgument,
                  G4String("UNKNOWN TAG IN FILE  "+wl[0]).c_str());
    }
    
  }
  
  
  //@@@@@@ Process files
  ProcessFiles();
  
}

CheckNColumns()

void DicomFileMgr::CheckNColumns	(	std::vector< G4String >	wl,
		size_t	vsizeTh
	)

Definition at line 103 of file DicomFileMgr.cc.

{
  if( wl.size() != vsizeTh ) {
    G4cerr << " Reading line " << G4endl;
    for( size_t ii = 0; ii < wl.size(); ii++){
      G4cerr << wl[ii] << " ";
    }
    G4cerr << G4endl;
    G4Exception("DICOM2G4",
                "D2G0010",
                FatalErrorInArgument,
                ("Wrong number of columns in line " + std::to_string(wl.size()) + " <> " 
                  + std::to_string(vsizeTh)).c_str());
  }
 
}

ProcessFiles()

void DicomFileMgr::ProcessFiles

(

)

Definition at line 311 of file DicomFileMgr.cc.

{
  if( theCTFiles.size() == 0 ) {
    G4Exception("CheckCTSlices",
                "DCM004",
                JustWarning,
                "No :FILE of type CT in input file");
  } else {
 
    CheckCTSlices();
    
    BuildCTMaterials();
    
    MergeCTFiles();
    
  }
 
  G4cout << " PROCESSING PET FILES " << thePETFiles.size() << G4endl; //GDEB
  if( thePETFiles.size() != 0 ) {
 
    CheckPETSlices();
    
    BuildPETActivities();
    
    MergePETFiles();
 
  }
 
  DumpToTextFile();
 
}

CheckCTSlices()

void DicomFileMgr::CheckCTSlices

(

)

Definition at line 344 of file DicomFileMgr.cc.

{
  size_t nSlices = theCTFiles.size();
  G4cout << " DicomFileMgr::Checking CT slices: " << nSlices << G4endl;
 
  G4bool uniformSliceThickness = true;
  
  if(nSlices > 1) {
    if(nSlices == 2) {
      mdct::const_iterator ite = theCTFiles.begin();
      DicomFileCT* one = (*ite).second;
      ite++;
      DicomFileCT* two = (*ite).second;
      
      G4double real_distance = (two->GetLocation()-one->GetLocation())/2.;
      
      if(one->GetMaxZ() != two->GetMinZ()) {
        one->SetMaxZ(one->GetLocation()+real_distance);
        two->SetMinZ(two->GetLocation()-real_distance);
        //one->SetMinZ(one->GetLocation()-real_distance);
        //two->SetMaxZ(two->GetLocation()+real_distance);
        if(uniformSliceThickness) {
          one->SetMinZ(one->GetLocation()-real_distance);
          two->SetMaxZ(two->GetLocation()+real_distance);
        }
      }
    } else {
      mdct::iterator ite0 = theCTFiles.begin();
      mdct::iterator ite1 = ite0; ite1++;
      mdct::iterator ite2 = ite1; ite2++;
      for(; ite2 != theCTFiles.end(); ++ite0, ++ite1, ++ite2) {        
        DicomFileCT* prev = (DicomFileCT*)((*ite0).second);
        DicomFileCT* slice = (DicomFileCT*)((*ite1).second);
        DicomFileCT* next = (DicomFileCT*)((*ite2).second);
        G4double real_up_distance = (next->GetLocation() -
                                      slice->GetLocation())/2.;
        G4double real_down_distance = (slice->GetLocation() -
                                      prev->GetLocation())/2.;
        G4double real_distance = real_up_distance + real_down_distance;
        G4double stated_distance = slice->GetMaxZ()-slice->GetMinZ();
 
        if(std::fabs(real_distance - stated_distance) > 1.E-9) {
          unsigned int sliceNum = std::distance(theCTFiles.begin(),ite1);
          G4cerr << "\tDicomFileMgr::CheckCTSlices - Slice Distance Error in slice [" << sliceNum 
                 << "]: Distance between this slice and slices up and down = "
                 << real_distance
                 << " <> Slice width = " << stated_distance 
                 << " Slice locations " <<prev->GetLocation() << " : " << slice->GetLocation() 
                 << " : " << next->GetLocation()
                 << " DIFFERENCE= " << real_distance - stated_distance
                 << G4endl;
          G4cerr << "!! WARNING: Geant4 will reset slice width so that it extends between " 
                 << "lower and upper slice " << G4endl;
 
          slice->SetMinZ(slice->GetLocation()-real_down_distance);
          slice->SetMaxZ(slice->GetLocation()+real_up_distance);
          
          if(ite0 == theCTFiles.begin()) {
            prev->SetMaxZ(slice->GetMinZ());
            // Using below would make all slice same thickness
            //prev->SetMinZ(prev->GetLocation()-real_min_distance);
            if(uniformSliceThickness) {
              prev->SetMinZ(prev->GetLocation()-real_down_distance);
            }            
          }
          if(static_cast<unsigned int>(std::distance(theCTFiles.begin(),ite2)+1)==
             nSlices) {
            next->SetMinZ(slice->GetMaxZ());
            // Using below would make all slice same thickness
            //next->SetMaxZ(next->GetLocation()+real_max_distance);
            if(uniformSliceThickness) {
              next->SetMaxZ(next->GetLocation()+real_up_distance); }
          }
        }
      }
    }
  }
  
}

Hounsfield2density()

G4double DicomFileMgr::Hounsfield2density

(

Uint32

Hval

)

Definition at line 217 of file DicomFileMgr.cc.

{
  if( theCT2Density.size() == 0 ) {
    G4Exception("Hounsfield2density",
                "DCM004",
                FatalException,
                "No :CT2D line in input file");
  }
  std::map<G4int,G4double>::const_iterator ite = theCT2Density.begin();
  G4int minHval = (*ite).first;
  if( G4int(Hval) < minHval ) {
    G4Exception("DicomHandler::Hounsfield2density",
                "",
                FatalException,
                ("Hval value too small, change input file "+std::to_string(Hval) + " < " 
                 + std::to_string(minHval)).c_str());
  }
 
  ite = theCT2Density.end(); ite--;
  G4int maxHval = (*ite).first;
  if( G4int(Hval) > maxHval ) {
    G4Exception("DicomHandler::Hval2density",
                "",
                FatalException,
                ("Hval value too big, change CT2Density.dat file "+std::to_string(Hval) + " > " 
                 + std::to_string(maxHval)).c_str());
  }
  
  G4float density = -1.;
  G4double deltaCT = 0;
  G4double deltaDensity = 0;
  
  ite = theCT2Density.upper_bound(Hval);
  std::map<G4int,G4double>::const_iterator itePrev = ite; itePrev--;
  
  deltaCT = (*ite).first - (*itePrev).first;
  deltaDensity = (*ite).second - (*itePrev).second;
  
  // interpolating linearly
  density = (*ite).second - (((*ite).first-Hval)*deltaDensity/deltaCT );
  
  if(density < 0.) {
    G4Exception("DicomFileMgr::Hounsfiled2Density",
                "DFM002",
                FatalException,
                G4String("@@@ Error negative density = " + std::to_string(density) + " from HV = " 
                 + std::to_string(Hval)).c_str());
  }
  
  //  G4cout << " Hval2density " << Hval << " -> " << density << G4endl;//GDEB
  return density;
  
}

GetMaterialIndex()

size_t DicomFileMgr::GetMaterialIndex

(

G4double

Hval

)

Definition at line 272 of file DicomFileMgr.cc.

{
  std::map<G4double,G4String>::iterator ite = theMaterials.upper_bound(Hval);
  if( ite == theMaterials.end() ) {
    ite--;
    G4Exception("DicomFileMgr::GetMaterialIndex",
                "DFM004",
                FatalException,
                ("Hounsfiled value too big, change input file "+std::to_string(Hval) + " > " 
                 + std::to_string((*ite).first)).c_str());
  }
 
  size_t dist = std::distance( theMaterials.begin(), ite );
  
  return  dist;
  
}

GetMaterialIndexByDensity()

size_t DicomFileMgr::GetMaterialIndexByDensity

(

G4double

density

)

Definition at line 292 of file DicomFileMgr.cc.

{
  std::map<G4double,G4String>::iterator ite = theMaterialsDensity.upper_bound(density);
  if( ite == theMaterialsDensity.end() ) {
    ite--;
    G4Exception("DicomFileMgr::GetMaterialIndexByDensity",
                "DFM003",
                FatalException,
                ("Density too big, change input file "+std::to_string(density) + " > " 
                 + std::to_string((*ite).first)).c_str());
  }
 
  size_t dist = std::distance( theMaterialsDensity.begin(), ite );
  
  return  dist;
  
}

BuildCTMaterials()

void DicomFileMgr::BuildCTMaterials

(

)

Definition at line 507 of file DicomFileMgr.cc.

{
  G4cout << " DicomFileMgr::Building Materials " << theCTFiles.size() << G4endl;//GDEB
  mdct::const_iterator ite = theCTFiles.begin();
  for( ; ite != theCTFiles.end(); ite++ ) {
    (*ite).second->BuildMaterials();
  }
}

MergeCTFiles()

void DicomFileMgr::MergeCTFiles

(

)

Definition at line 527 of file DicomFileMgr.cc.

{
  G4cout << " DicomFileMgr::Merging CT Files " << theCTFiles.size() << G4endl;//GDEB
  mdct::const_iterator ite = theCTFiles.begin();
  theCTFileAll = new DicomFileCT( *((*ite).second) );
  ite++;
  for( ; ite != theCTFiles.end(); ite++ ) {
    (*theCTFileAll) +=  *((*ite).second);
  }
}

CheckPETSlices()

void DicomFileMgr::CheckPETSlices

(

)

Definition at line 425 of file DicomFileMgr.cc.

{
  size_t nSlices = thePETFiles.size();
  G4cout << " DicomFileMgr::Checking PET slices: " << nSlices << G4endl;
 
  G4bool uniformSliceThickness = true;
  
  if(nSlices > 1) {
    if(nSlices == 2) {
      mdpet::const_iterator ite = thePETFiles.begin();
      DicomFilePET* one = (*ite).second;
      ite++;
      DicomFilePET* two = (*ite).second;
      
      G4double real_distance = (two->GetLocation()-one->GetLocation())/2.;
      
      if(one->GetMaxZ() != two->GetMinZ()) {
        one->SetMaxZ(one->GetLocation()+real_distance);
        two->SetMinZ(two->GetLocation()-real_distance);
        //one->SetMinZ(one->GetLocation()-real_distance);
        //two->SetMaxZ(two->GetLocation()+real_distance);
        if(uniformSliceThickness) {
          one->SetMinZ(one->GetLocation()-real_distance);
          two->SetMaxZ(two->GetLocation()+real_distance);
        }
      }
    } else {
      mdpet::iterator ite0 = thePETFiles.begin();
      mdpet::iterator ite1 = ite0; ite1++;
      mdpet::iterator ite2 = ite1; ite2++;
      for(; ite2 != thePETFiles.end(); ++ite0, ++ite1, ++ite2) {        
        DicomFilePET* prev = (DicomFilePET*)((*ite0).second);
        DicomFilePET* slice = (DicomFilePET*)((*ite1).second);
        DicomFilePET* next = (DicomFilePET*)((*ite2).second);
        G4double real_up_distance = (next->GetLocation() -
                                      slice->GetLocation())/2.;
        G4double real_down_distance = (slice->GetLocation() -
                                      prev->GetLocation())/2.;
        G4double real_distance = real_up_distance + real_down_distance;
        G4double stated_distance = slice->GetMaxZ()-slice->GetMinZ();
 
        if(std::fabs(real_distance - stated_distance) > 1.E-9) {
          unsigned int sliceNum = std::distance(thePETFiles.begin(),ite1);
          G4cerr << "\tDicomFileMgr::CheckPETSlices - Slice Distance Error in slice [" << sliceNum 
                 << "]: Distance between this slice and slices up and down = "
                 << real_distance
                 << " <> Slice width = " << stated_distance 
                 << " Slice locations " <<prev->GetLocation() << " : " << slice->GetLocation() 
                 << " : " << next->GetLocation()
                 << " DIFFERENCE= " << real_distance - stated_distance
                 << G4endl;
          G4cerr << "!! WARNING: Geant4 will reset slice width so that it extends between " 
                 << "lower and upper slice " << G4endl;
 
          slice->SetMinZ(slice->GetLocation()-real_down_distance);
          slice->SetMaxZ(slice->GetLocation()+real_up_distance);
          
          if(ite0 == thePETFiles.begin()) {
            prev->SetMaxZ(slice->GetMinZ());
            // Using below would make all slice same thickness
            //prev->SetMinZ(prev->GetLocation()-real_min_distance);
            if(uniformSliceThickness) {
              prev->SetMinZ(prev->GetLocation()-real_down_distance);
            }            
          }
          if(static_cast<unsigned int>(std::distance(thePETFiles.begin(),ite2)+1)==
             nSlices) {
            next->SetMinZ(slice->GetMaxZ());
            // Using below would make all slice same thickness
            //next->SetMaxZ(next->GetLocation()+real_max_distance);
            if(uniformSliceThickness) {
              next->SetMaxZ(next->GetLocation()+real_up_distance); }
          }
        }
      }
    }
  }
  
}

BuildPETActivities()

void DicomFileMgr::BuildPETActivities

(

)

Definition at line 517 of file DicomFileMgr.cc.

{
  G4cout << " DicomFileMgr::Building PETData " << thePETFiles.size() << G4endl;//GDEB
  mdpet::const_iterator ite = thePETFiles.begin();
  for( ; ite != thePETFiles.end(); ite++ ) {
    (*ite).second->BuildActivities();
  }
}

MergePETFiles()

void DicomFileMgr::MergePETFiles

(

)

Definition at line 540 of file DicomFileMgr.cc.

{
  G4cout << " DicomFileMgr::Merging PET Files " << thePETFiles.size() << G4endl;//GDEB
  mdpet::const_iterator ite = thePETFiles.begin();
  thePETFileAll = new DicomFilePET( *((*ite).second) );
  ite++;
  for( ; ite != thePETFiles.end(); ite++ ) {
    (*thePETFileAll) +=  *((*ite).second);
  }
}

DumpToTextFile()

void DicomFileMgr::DumpToTextFile

(

)

Definition at line 553 of file DicomFileMgr.cc.

{
  G4cout << " DicomFileMgr::Dumping To Text File " << G4endl; //GDEB
  if( theCTFiles.size() != 0 ) {
    std::ofstream fout(theFileOutName);
 
    if( !bMaterialsDensity ) {
      fout << theMaterials.size() << std::endl;
      std::map<G4double,G4String>::const_iterator ite;
      G4int ii = 0;
      for(ite = theMaterials.begin(); ite != theMaterials.end(); ite++, ii++){
        fout << ii << " \"" << (*ite).second << "\"" << std::endl;
      }
    } else {
      fout << theMaterialsDensity.size() << std::endl;
      std::map<G4double,G4String>::const_iterator ite;
      G4int ii = 0;
      for(ite = theMaterialsDensity.begin(); ite != theMaterialsDensity.end(); ite++, ii++){
        fout << ii << " \"" << (*ite).second << "\"" << std::endl;
      }
    }
    
    theCTFileAll->DumpHeaderToTextFile(fout);
    for( mdct::const_iterator itect = theCTFiles.begin(); itect != theCTFiles.end(); itect++ ) {
      (*itect).second->DumpMateIDsToTextFile(fout);
    }
    for( mdct::const_iterator itect = theCTFiles.begin(); itect != theCTFiles.end(); itect++ ) {
      (*itect).second->DumpDensitiesToTextFile(fout);
    }
    for( mdct::const_iterator itect = theCTFiles.begin(); itect != theCTFiles.end(); itect++ ) {
      (*itect).second->BuildStructureIDs();
      (*itect).second->DumpStructureIDsToTextFile(fout);
    }
    
    std::vector<DicomFileStructure*> dfs = GetStructFiles();
    for( size_t i1 = 0; i1 < dfs.size(); i1++ ){
      std::vector<DicomROI*> rois = dfs[i1]->GetROIs();
      for( size_t i2 = 0; i2 < rois.size(); i2++ ){
        fout << rois[i2]->GetNumber()+1 << " \"" << rois[i2]->GetName() << "\"" <<G4endl;
      }
    }
  }
 
  if( thePETFiles.size() != 0 ) {
    std::ofstream fout(theFileOutName);
 
    thePETFileAll->DumpHeaderToTextFile(fout);
    for( mdpet::const_iterator itect = thePETFiles.begin(); itect != thePETFiles.end(); itect++ ) {
      (*itect).second->DumpActivitiesToTextFile(fout);
    }
  }
 
  for( size_t i1 = 0; i1 < thePlanFiles.size(); i1++ ){
    thePlanFiles[i1]->DumpToFile();
  }
 
}

SetStructureNCheck()

void DicomFileMgr::SetStructureNCheck ( G4int  nsc )

inline

Definition at line 79 of file DicomFileMgr.hh.

                                      {
    theStructureNCheck = nsc;
  }

GetStructureNCheck()

G4int DicomFileMgr::GetStructureNCheck ( ) const

inline

Definition at line 82 of file DicomFileMgr.hh.

                                   {
    return theStructureNCheck;
  }

SetStructureNMaxROI()

void DicomFileMgr::SetStructureNMaxROI ( G4int  nsc )

inline

Definition at line 85 of file DicomFileMgr.hh.

                                       {
    theStructureNMaxROI = nsc;
  }

GetStructureNMaxROI()

G4int DicomFileMgr::GetStructureNMaxROI ( ) const

inline

Definition at line 88 of file DicomFileMgr.hh.

                                    {
    return theStructureNMaxROI;
  }

GetCompression()

G4int DicomFileMgr::GetCompression ( ) const

inline

Definition at line 91 of file DicomFileMgr.hh.

                               {
    return fCompression;
  }

GetFileOutName()

G4String DicomFileMgr::GetFileOutName ( ) const

inline

Definition at line 94 of file DicomFileMgr.hh.

                                  {
    return theFileOutName;
  }

SetControlPointMetersets()

void DicomFileMgr::SetControlPointMetersets

(

)

IsMaterialsDensity()

G4bool DicomFileMgr::IsMaterialsDensity ( ) const

inline

Definition at line 99 of file DicomFileMgr.hh.

                                    {
    return bMaterialsDensity;
  }

Member Data Documentation

fCompression

G4int DicomFileMgr::fCompression

protected

Definition at line 104 of file DicomFileMgr.hh.

theInstance

DicomFileMgr * DicomFileMgr::theInstance = 0

staticprivate

Definition at line 107 of file DicomFileMgr.hh.

theFileOutName

G4String DicomFileMgr::theFileOutName

private

Definition at line 109 of file DicomFileMgr.hh.

theCTFiles

mdct DicomFileMgr::theCTFiles

private

Definition at line 111 of file DicomFileMgr.hh.

theStructFiles

std::vector<DicomFileStructure*> DicomFileMgr::theStructFiles

private

Definition at line 112 of file DicomFileMgr.hh.

thePlanFiles

std::vector<DicomFilePlan*> DicomFileMgr::thePlanFiles

private

Definition at line 113 of file DicomFileMgr.hh.

thePETFiles

mdpet DicomFileMgr::thePETFiles

private

Definition at line 114 of file DicomFileMgr.hh.

theMaterials

std::map<G4double,G4String> DicomFileMgr::theMaterials

private

Definition at line 115 of file DicomFileMgr.hh.

theMaterialsDensity

std::map<G4double,G4String> DicomFileMgr::theMaterialsDensity

private

Definition at line 116 of file DicomFileMgr.hh.

theCT2Density

std::map<G4int,G4double> DicomFileMgr::theCT2Density

private

Definition at line 117 of file DicomFileMgr.hh.

theCTFileAll

DicomFileCT* DicomFileMgr::theCTFileAll

private

Definition at line 119 of file DicomFileMgr.hh.

thePETFileAll

DicomFilePET* DicomFileMgr::thePETFileAll

private

Definition at line 120 of file DicomFileMgr.hh.

theStructureNCheck

G4int DicomFileMgr::theStructureNCheck

private

Definition at line 121 of file DicomFileMgr.hh.

theStructureNMaxROI

G4int DicomFileMgr::theStructureNMaxROI

private

Definition at line 122 of file DicomFileMgr.hh.

verbose

int DicomFileMgr::verbose = 1

static

Definition at line 125 of file DicomFileMgr.hh.

bMaterialsDensity

G4bool DicomFileMgr::bMaterialsDensity

Definition at line 126 of file DicomFileMgr.hh.

---

The documentation for this class was generated from the following files:

• .doxygen/Doxymodules_medical.h
• extended/medical/DICOM/dicomReader/include/DicomFileMgr.hh
• extended/medical/DICOM/dicomReader/src/DicomFileMgr.cc