DicomPhantomZSliceHeader Class Reference

DicomPhantomZSliceHeader class. More...

#include <Doxymodules_medical.h>

Public Member Functions
	DicomPhantomZSliceHeader (const G4String &)
	DicomPhantomZSliceHeader (const DicomPhantomZSliceHeader &)=default
	DicomPhantomZSliceHeader (std::ifstream &fin)
	~DicomPhantomZSliceHeader ()
G4int	GetNoVoxelsX () const
G4int	GetNoVoxelsY () const
G4int	GetNoVoxelsZ () const
G4int	GetNoVoxels () const
G4double	GetMinX () const
G4double	GetMinY () const
G4double	GetMinZ () const
G4double	GetMaxX () const
G4double	GetMaxY () const
G4double	GetMaxZ () const
G4double	GetVoxelHalfX () const
G4double	GetVoxelHalfY () const
G4double	GetVoxelHalfZ () const
const std::vector< G4String > &	GetMaterialNames () const
void	SetNoVoxelsX (const G4int &val)
void	SetNoVoxelsY (const G4int &val)
void	SetNoVoxelsZ (const G4int &val)
void	SetMinX (const G4double &val)
void	SetMaxX (const G4double &val)
void	SetMinY (const G4double &val)
void	SetMaxY (const G4double &val)
void	SetMinZ (const G4double &val)
void	SetMaxZ (const G4double &val)
void	SetMaterialNames (std::vector< G4String > &mn)
void	operator+= (const DicomPhantomZSliceHeader &rhs)
DicomPhantomZSliceHeader	operator+ (const DicomPhantomZSliceHeader &rhs)
void	SetFilename (const G4String &val)
void	SetSliceLocation (const G4double &val)
void	AddMaterial (const G4String &val)
const G4double &	GetSliceLocation () const
void	AddRow ()
void	AddValue (G4double val)
void	AddValue (const std::vector< G4double > &val)
void	AddValue (const std::vector< std::vector< G4double > > &val)
void	AddMateID (G4int val)
void	AddMateID (const std::vector< G4int > &val)
void	AddMateID (const std::vector< std::vector< G4int > > &val)
const std::vector< std::vector< G4double > > &	GetValues () const
const std::vector< std::vector< G4int > > &	GetMateIDs () const
void	DumpToFile ()
void	ReadDataFromFile ()
void	DumpExcessMemory ()
void	FlipData ()

Private Member Functions
G4bool	IsInteger (const G4String &)
template<typename T >
void	Print (std::ostream &, const std::vector< T > &, const G4String &, G4int breakLine=-1)
template<typename T >
T	G4s2n (const G4String &)
template<typename T >
bool	CheckConsistency (const T &, const T &, G4String)
G4bool	CheckMaterialExists (const G4String &mateName)

Private Attributes
G4int	fNoVoxelsX
G4int	fNoVoxelsY
G4int	fNoVoxelsZ
G4double	fMinX
G4double	fMinY
G4double	fMinZ
G4double	fMaxX
G4double	fMaxY
G4double	fMaxZ
std::vector< G4String >	fMaterialNames
G4String	fFilename
std::vector< std::vector< G4double > >	fValues
std::vector< std::vector< G4int > >	fMateIDs
G4double	fSliceLocation

Detailed Description

DicomPhantomZSliceHeader class.

Contains the meta data information corresponding to one or several Z slices (number of voxels, dimension)

History: 30.11.07 First version

Author

P. Arce

Definition at line 27 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

DicomPhantomZSliceHeader() [1/3]

DicomPhantomZSliceHeader::DicomPhantomZSliceHeader

(

const G4String &

fname

)

Definition at line 41 of file DicomPhantomZSliceHeader.cc.

:   fNoVoxelsX(0),fNoVoxelsY(0),fNoVoxelsZ(0),
    fMinX(0),fMinY(0),fMinZ(0),
    fMaxX(0),fMaxY(0),fMaxZ(0),
    fFilename(fname),fSliceLocation(0)
{
 
}

DicomPhantomZSliceHeader() [2/3]

DicomPhantomZSliceHeader::DicomPhantomZSliceHeader ( const DicomPhantomZSliceHeader &  )

default

DicomPhantomZSliceHeader() [3/3]

DicomPhantomZSliceHeader::DicomPhantomZSliceHeader

(

std::ifstream &

fin

)

Definition at line 57 of file DicomPhantomZSliceHeader.cc.

{
    //----- Read material indices and names
    G4int nmate;
    G4String mateindex;
    G4String matename;
    fin >> nmate;
#ifdef G4VERBOSE
    G4cout << " DicomPhantomZSliceHeader reading number of materials " 
           << nmate << G4endl;
#endif
 
    for( G4int im = 0; im < nmate; im++ ){
        fin >> mateindex >> matename;
#ifdef G4VERBOSE
        //G4cout << " DicomPhantomZSliceHeader reading material " 
        // << im << " : "<< mateindex << "  " << matename << G4endl;
#endif
 
        if( ! CheckMaterialExists( matename ) ) {
            G4Exception("DicomPhantomZSliceHeader::DicomPhantomZSliceHeader",
            "A material is found in file that is not built in the C++ code",
            FatalErrorInArgument, matename.c_str());
        }
 
        fMaterialNames.push_back(matename);
    }
 
    //----- Read number of voxels
    fin >> fNoVoxelsX >> fNoVoxelsY >> fNoVoxelsZ;
#ifdef G4VERBOSE
    G4cout << " Number of voxels " << fNoVoxelsX << " " << fNoVoxelsY 
           << " " << fNoVoxelsZ << G4endl;
#endif
 
    //----- Read minimal and maximal extensions (= walls of phantom)
    fin >> fMinX >> fMaxX;
    fin >> fMinY >> fMaxY;
    fin >> fMinZ >> fMaxZ;
#ifdef G4VERBOSE
    G4cout << " Extension in X " << fMinX << " " << fMaxX << G4endl
    << " Extension in Y " << fMinY << " " << fMaxY << G4endl
    << " Extension in Z " << fMinZ << " " << fMaxZ << G4endl;
#endif
 
    fSliceLocation = 0.5*(fMinZ + fMaxZ);
}

~DicomPhantomZSliceHeader()

DicomPhantomZSliceHeader::~DicomPhantomZSliceHeader

(

)

Definition at line 51 of file DicomPhantomZSliceHeader.cc.

{
 
}

Member Function Documentation

GetNoVoxelsX()

G4int DicomPhantomZSliceHeader::GetNoVoxelsX ( ) const

inline

Definition at line 64 of file DicomPhantomZSliceHeader.hh.

{ return fNoVoxelsX; };

GetNoVoxelsY()

G4int DicomPhantomZSliceHeader::GetNoVoxelsY ( ) const

inline

Definition at line 65 of file DicomPhantomZSliceHeader.hh.

{ return fNoVoxelsY; };

GetNoVoxelsZ()

G4int DicomPhantomZSliceHeader::GetNoVoxelsZ ( ) const

inline

Definition at line 66 of file DicomPhantomZSliceHeader.hh.

{ return fNoVoxelsZ; };

GetNoVoxels()

G4int DicomPhantomZSliceHeader::GetNoVoxels ( ) const

inline

Definition at line 67 of file DicomPhantomZSliceHeader.hh.

{ return fNoVoxelsX*fNoVoxelsY*fNoVoxelsZ; };

GetMinX()

G4double DicomPhantomZSliceHeader::GetMinX ( ) const

inline

Definition at line 69 of file DicomPhantomZSliceHeader.hh.

{ return fMinX; };

GetMinY()

G4double DicomPhantomZSliceHeader::GetMinY ( ) const

inline

Definition at line 70 of file DicomPhantomZSliceHeader.hh.

{ return fMinY; };

GetMinZ()

G4double DicomPhantomZSliceHeader::GetMinZ ( ) const

inline

Definition at line 71 of file DicomPhantomZSliceHeader.hh.

{ return fMinZ; };

GetMaxX()

G4double DicomPhantomZSliceHeader::GetMaxX ( ) const

inline

Definition at line 72 of file DicomPhantomZSliceHeader.hh.

{ return fMaxX; };

GetMaxY()

G4double DicomPhantomZSliceHeader::GetMaxY ( ) const

inline

Definition at line 73 of file DicomPhantomZSliceHeader.hh.

{ return fMaxY; };

GetMaxZ()

G4double DicomPhantomZSliceHeader::GetMaxZ ( ) const

inline

Definition at line 74 of file DicomPhantomZSliceHeader.hh.

{ return fMaxZ; };

GetVoxelHalfX()

G4double DicomPhantomZSliceHeader::GetVoxelHalfX ( ) const

inline

Definition at line 76 of file DicomPhantomZSliceHeader.hh.

{ return (fMaxX-fMinX)/fNoVoxelsX/2.; };

GetVoxelHalfY()

G4double DicomPhantomZSliceHeader::GetVoxelHalfY ( ) const

inline

Definition at line 77 of file DicomPhantomZSliceHeader.hh.

{ return (fMaxY-fMinY)/fNoVoxelsY/2.; };

GetVoxelHalfZ()

G4double DicomPhantomZSliceHeader::GetVoxelHalfZ ( ) const

inline

Definition at line 78 of file DicomPhantomZSliceHeader.hh.

{ return (fMaxZ-fMinZ)/fNoVoxelsZ/2.; };

GetMaterialNames()

const std::vector< G4String > & DicomPhantomZSliceHeader::GetMaterialNames ( ) const

inline

Definition at line 80 of file DicomPhantomZSliceHeader.hh.

{ return fMaterialNames; };

SetNoVoxelsX()

void DicomPhantomZSliceHeader::SetNoVoxelsX ( const G4int &  val )

inline

Definition at line 82 of file DicomPhantomZSliceHeader.hh.

{ fNoVoxelsX = val; }

SetNoVoxelsY()

void DicomPhantomZSliceHeader::SetNoVoxelsY ( const G4int &  val )

inline

Definition at line 83 of file DicomPhantomZSliceHeader.hh.

{ fNoVoxelsY = val; }

SetNoVoxelsZ()

void DicomPhantomZSliceHeader::SetNoVoxelsZ ( const G4int &  val )

inline

Definition at line 84 of file DicomPhantomZSliceHeader.hh.

{ fNoVoxelsZ = val; }

SetMinX()

void DicomPhantomZSliceHeader::SetMinX ( const G4double &  val )

inline

Definition at line 86 of file DicomPhantomZSliceHeader.hh.

{ fMinX = val; };

SetMaxX()

void DicomPhantomZSliceHeader::SetMaxX ( const G4double &  val )

inline

Definition at line 87 of file DicomPhantomZSliceHeader.hh.

{ fMaxX = val; };

SetMinY()

void DicomPhantomZSliceHeader::SetMinY ( const G4double &  val )

inline

Definition at line 88 of file DicomPhantomZSliceHeader.hh.

{ fMinY = val; };

SetMaxY()

void DicomPhantomZSliceHeader::SetMaxY ( const G4double &  val )

inline

Definition at line 89 of file DicomPhantomZSliceHeader.hh.

{ fMaxY = val; };

SetMinZ()

void DicomPhantomZSliceHeader::SetMinZ ( const G4double &  val )

inline

Definition at line 90 of file DicomPhantomZSliceHeader.hh.

{ fMinZ = val; };

SetMaxZ()

void DicomPhantomZSliceHeader::SetMaxZ ( const G4double &  val )

inline

Definition at line 91 of file DicomPhantomZSliceHeader.hh.

{ fMaxZ = val; };

SetMaterialNames()

void DicomPhantomZSliceHeader::SetMaterialNames ( std::vector< G4String > &  mn )

inline

Definition at line 93 of file DicomPhantomZSliceHeader.hh.

{ fMaterialNames = mn; }

operator+=()

void DicomPhantomZSliceHeader::operator+=

(

const DicomPhantomZSliceHeader &

rhs

)

Definition at line 124 of file DicomPhantomZSliceHeader.cc.

{
    *this = *this + rhs;
}

operator+()

DicomPhantomZSliceHeader DicomPhantomZSliceHeader::operator+

(

const DicomPhantomZSliceHeader &

rhs

)

Definition at line 130 of file DicomPhantomZSliceHeader.cc.

{
    //----- Check that both slices has the same dimensions
    if( fNoVoxelsX != rhs.GetNoVoxelsX()
       || fNoVoxelsY != rhs.GetNoVoxelsY() ) {
        G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
        !!! Different number of voxels: "
        << "  X= " << fNoVoxelsX << " =? " << rhs.GetNoVoxelsX()
        << "  Y=  " << fNoVoxelsY << " =? " << rhs.GetNoVoxelsY()
        << "  Z=  " << fNoVoxelsZ << " =? " << rhs.GetNoVoxelsZ()
        << G4endl;
        G4Exception("DicomPhantomZSliceHeader::DicomPhantomZSliceHeader",
        "",FatalErrorInArgument,"");
    }
    //----- Check that both slices has the same extensions
    if( fMinX != rhs.GetMinX() || fMaxX != rhs.GetMaxX()
       || fMinY != rhs.GetMinY() || fMaxY != rhs.GetMaxY() ) {
        G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
        !!! Different extensions: "
        << "  Xmin= " << fMinX << " =? " << rhs.GetMinX()
        << "  Xmax= " << fMaxX << " =? " << rhs.GetMaxX()
        << "  Ymin= " << fMinY << " =? " << rhs.GetMinY()
        << "  Ymax= " << fMaxY << " =? " << rhs.GetMaxY()
        << G4endl;
        G4Exception("DicomPhantomZSliceHeader::operator+","",
                    FatalErrorInArgument,"");
    }
 
    //----- Check that both slices have the same materials
    std::vector<G4String> fMaterialNames2 = rhs.GetMaterialNames();
    if( fMaterialNames.size() != fMaterialNames2.size() ) {
        G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
        !!! Different number of materials: " << fMaterialNames.size() << " =? "
        << fMaterialNames2.size() << G4endl;
        G4Exception("DicomPhantomZSliceHeader::operator+","",
                    FatalErrorInArgument,"");
    }
    for( unsigned int ii = 0; ii < fMaterialNames.size(); ii++ ) {
        if( fMaterialNames[ii] != fMaterialNames2[ii] ) {
            G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
            !!! Different material number " << ii << " : " 
                   << fMaterialNames[ii] << " =? "
            << fMaterialNames2[ii] << G4endl;
            G4Exception("DicomPhantomZSliceHeader::operator+","",
                        FatalErrorInArgument,"");
        }
    }
 
    //----- Check that the slices are contiguous in Z
    if( std::fabs( fMinZ - rhs.GetMaxZ() ) >
    G4GeometryTolerance::GetInstance()->GetRadialTolerance() &&
       std::fabs( fMaxZ - rhs.GetMinZ() ) >
       G4GeometryTolerance::GetInstance()->GetRadialTolerance() ){
        G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:!!!\
        Slices are not contiguous in Z "
        << "  Zmin= " << fMinZ << " & " << rhs.GetMinZ()
        << "  Zmax= " << fMaxZ << " & " << rhs.GetMaxZ()
        << G4endl;
        G4Exception("DicomPhantomZSliceHeader::operator+","",
                    FatalErrorInArgument,"");
    }
 
    //----- Build slice header copying first one
    DicomPhantomZSliceHeader temp( *this );
 
    //----- Add data from second slice header
    temp.SetMinZ( std::min( fMinZ, rhs.GetMinZ() ) );
    temp.SetMaxZ( std::max( fMaxZ, rhs.GetMaxZ() ) );
    temp.SetNoVoxelsZ( fNoVoxelsZ + rhs.GetNoVoxelsZ() );
 
    return temp;
}

SetFilename()

void DicomPhantomZSliceHeader::SetFilename ( const G4String &  val )

inline

Definition at line 113 of file DicomPhantomZSliceHeader.hh.

{ fFilename = val; }

SetSliceLocation()

void DicomPhantomZSliceHeader::SetSliceLocation ( const G4double &  val )

inline

Definition at line 114 of file DicomPhantomZSliceHeader.hh.

{ fSliceLocation = val; }

AddMaterial()

void DicomPhantomZSliceHeader::AddMaterial ( const G4String &  val )

inline

Definition at line 115 of file DicomPhantomZSliceHeader.hh.

{ fMaterialNames.push_back(val); }

GetSliceLocation()

const G4double & DicomPhantomZSliceHeader::GetSliceLocation ( ) const

inline

Definition at line 117 of file DicomPhantomZSliceHeader.hh.

{ return fSliceLocation; }

AddRow()

void DicomPhantomZSliceHeader::AddRow ( )

inline

Definition at line 119 of file DicomPhantomZSliceHeader.hh.

                { fValues.push_back(std::vector<G4double>(0)); 
    fMateIDs.push_back(std::vector<G4int>(0)); }

AddValue() [1/3]

void DicomPhantomZSliceHeader::AddValue ( G4double  val )

inline

Definition at line 122 of file DicomPhantomZSliceHeader.hh.

                              { (fValues.size() > 0) ? 
      fValues.back().push_back(val) : 
      fValues.push_back(std::vector<G4double>(1,val)); }

AddValue() [2/3]

void DicomPhantomZSliceHeader::AddValue ( const std::vector< G4double > &  val )

inline

Definition at line 125 of file DicomPhantomZSliceHeader.hh.

{ fValues.push_back(val); }

AddValue() [3/3]

void DicomPhantomZSliceHeader::AddValue ( const std::vector< std::vector< G4double > > &  val )

inline

Definition at line 126 of file DicomPhantomZSliceHeader.hh.

                                                            {
    for(unsigned int i = 0; i < val.size(); ++i) { fValues.push_back(val.at(i)); }
  }

AddMateID() [1/3]

void DicomPhantomZSliceHeader::AddMateID ( G4int  val )

inline

Definition at line 130 of file DicomPhantomZSliceHeader.hh.

                            { (fMateIDs.size() > 0) ? 
      fMateIDs.back().push_back(val) : 
      fMateIDs.push_back(std::vector<G4int>(1,val)); }

AddMateID() [2/3]

void DicomPhantomZSliceHeader::AddMateID ( const std::vector< G4int > &  val )

inline

Definition at line 133 of file DicomPhantomZSliceHeader.hh.

{ fMateIDs.push_back(val); }

AddMateID() [3/3]

void DicomPhantomZSliceHeader::AddMateID ( const std::vector< std::vector< G4int > > &  val )

inline

Definition at line 134 of file DicomPhantomZSliceHeader.hh.

                                                          {
    for(unsigned int i = 0; i < val.size(); ++i) { fMateIDs.push_back(val.at(i)); }
  }

GetValues()

const std::vector< std::vector< G4double > > & DicomPhantomZSliceHeader::GetValues ( ) const

inline

Definition at line 138 of file DicomPhantomZSliceHeader.hh.

{ return fValues; }

GetMateIDs()

const std::vector< std::vector< G4int > > & DicomPhantomZSliceHeader::GetMateIDs ( ) const

inline

Definition at line 139 of file DicomPhantomZSliceHeader.hh.

{ return fMateIDs; }

DumpToFile()

void DicomPhantomZSliceHeader::DumpToFile

(

)

Definition at line 205 of file DicomPhantomZSliceHeader.cc.

{
 
  G4cout << "DicomPhantomZSliceHeader::Dumping Z Slice data to " 
         << fFilename << "..." << G4endl;
  //sleep(5);
  
  //  May seen counter-intuitive (dumping to file you are reading from), but
  //  the reason for this is modification slice spacing
  if(fMateIDs.size() == 0 || fValues.size() == 0) { ReadDataFromFile(); }
  
  
  std::ofstream out;
  out.open(fFilename.c_str());
  
  if(!out) {
    G4String descript = "DicomPhantomZSliceHeader::DumpToFile: could not open "
      +fFilename;
    G4Exception(descript.c_str(),"", FatalException, "");
  }
  
  out << fMaterialNames.size() << std::endl;
  for(unsigned int i = 0; i < fMaterialNames.size(); ++i) {
    out << i << " " << fMaterialNames.at(i) << std::endl;
  }
  
  out << fNoVoxelsX << " " << fNoVoxelsY << " " << fNoVoxelsZ << std::endl;
  out << fMinX << " " << fMaxX << std::endl;
  out << fMinY << " " << fMaxY << std::endl;
  out << fMinZ << " " << fMaxZ << std::endl;
  
  for(unsigned int i = 0; i < fMateIDs.size(); ++i) 
                           { Print(out,fMateIDs.at(i)," "); }
 
  for(unsigned int i = 0; i < fValues.size(); ++i) 
                           { Print(out,fValues.at(i)," ",6); }
  
  out.close();
  
}

ReadDataFromFile()

void DicomPhantomZSliceHeader::ReadDataFromFile

(

)

Definition at line 247 of file DicomPhantomZSliceHeader.cc.

{
  std::ifstream in;
  in.open(fFilename.c_str());
  
  if(!in) {
    G4String descript = "DicomPhantomZSliceHeader::DumpToFile: could not open "
      +fFilename;
    G4Exception(descript.c_str(),"", FatalException, "");
  }
  
  G4int nMaterials;
  in >> nMaterials;
  
  fMaterialNames.resize(nMaterials,"");
  for(G4int i = 0; i < nMaterials; ++i) {
    G4String str1, str2;
    in >> str1 >> str2;
    if(!IsInteger(str1)) {
      G4String descript = "String : " + str1 + " supposed to be integer";
      G4Exception("DicomPhantomZSliceHeader::ReadDataFromFile - error in \
       formatting: missing material index","", FatalException,descript.c_str());
    }
    G4int index = G4s2n<G4int>(str1);
    if(index > nMaterials || index < 0) {
      G4String descript = "Index : " + str1;
      G4Exception("DicomPhantomZSliceHeader::ReadDataFromFile - error:\
            bad material index","", FatalException,descript.c_str());
    }
    fMaterialNames[index] = str2;
  }
  
  in >> fNoVoxelsX >> fNoVoxelsY >> fNoVoxelsZ;
  
  G4double tmpMinX, tmpMinY, tmpMinZ;
  G4double tmpMaxX, tmpMaxY, tmpMaxZ;
  
  in >> tmpMinX >> tmpMaxX;
  in >> tmpMinY >> tmpMaxY;
  in >> tmpMinZ >> tmpMaxZ;
  
  fMinX = (CheckConsistency(tmpMinX,fMinX,"Min X value")) ?
    fMinX : ((fMinX == 0) ? tmpMinX : fMinX);
  fMaxX = (CheckConsistency(tmpMaxX,fMaxX,"Max X value")) ?
    fMaxX : ((fMaxX == 0) ? tmpMaxX : fMaxX);
  
  fMinY = (CheckConsistency(tmpMinY,fMinY,"Min Y value")) ?
    fMinY : ((fMinY == 0) ? tmpMinY : fMinY);
  fMaxY = (CheckConsistency(tmpMaxY,fMaxY,"Max Y value")) ?
    fMaxY : ((fMaxY == 0) ? tmpMaxY : fMaxY);
  
  fMinZ = (CheckConsistency(tmpMinZ,fMinZ,"Min Z value")) ?
    fMinZ : ((fMinZ == 0) ? tmpMinZ : fMinZ);
  fMaxZ = (CheckConsistency(tmpMaxZ,fMaxZ,"Max Z value")) ?
    fMaxZ : ((fMaxZ == 0) ? tmpMaxZ : fMaxZ);
  
  fMateIDs.clear();
  fValues.clear();
  fMateIDs.resize(fNoVoxelsY*fNoVoxelsZ,std::vector<G4int>(fNoVoxelsX,0));
  fValues.resize(fNoVoxelsY*fNoVoxelsZ,std::vector<G4double>(fNoVoxelsX,0.));
  for(G4int k = 0; k < fNoVoxelsZ; ++k) {
    for(G4int j = 0; j < fNoVoxelsY; ++j) {
      for(G4int i = 0; i < fNoVoxelsX; ++i) {
        G4int tmpMateID;
        in >> tmpMateID;
        G4int row = j*(k+1);
        fMateIDs[row][i] = tmpMateID;
      }
    }
  }
  
  for(G4int k = 0; k < fNoVoxelsZ; ++k) {
    for(G4int j = 0; j < fNoVoxelsY; ++j) {
      for(G4int i = 0; i < fNoVoxelsX; ++i) {
        G4double tmpValue;
        in >> tmpValue;
        G4int row = j*(k+1);
        fValues[row][i] = tmpValue;
      }
    }
  }
  
  in.close();
}

DumpExcessMemory()

void DicomPhantomZSliceHeader::DumpExcessMemory ( )

inline

Definition at line 144 of file DicomPhantomZSliceHeader.hh.

                          { 
    if(fFilename.length() != 0) { fValues.clear(); fMateIDs.clear(); } }

FlipData()

void DicomPhantomZSliceHeader::FlipData ( )

inline

Definition at line 181 of file DicomPhantomZSliceHeader.hh.

{
  std::reverse(fValues.begin(), fValues.end());
  std::reverse(fMateIDs.begin(), fMateIDs.end());    
}

IsInteger()

G4bool DicomPhantomZSliceHeader::IsInteger ( const G4String &  str )

inlineprivate

Definition at line 187 of file DicomPhantomZSliceHeader.hh.

{
  return (str.find_first_not_of("0123456789") == std::string::npos) ? true : false;
}

Print()

template<typename T >

void DicomPhantomZSliceHeader::Print ( std::ostream &  out, const std::vector< T > &  val, const G4String &  delim, G4int  breakLine = -1  )

inlineprivate

Definition at line 215 of file DicomPhantomZSliceHeader.hh.

{
  for(unsigned int i = 0; i < val.size(); ++i) {
    out << val.at(i);
    if(breakLine < 0) {
      if(i+1 < val.size()) { out << delim; }
      else { out << G4endl; }
    } else {
      ((i != 0 && i%breakLine == 0) ? (out << G4endl) : (out << delim)); }
  }
}

G4s2n()

template<typename T >

T DicomPhantomZSliceHeader::G4s2n ( const G4String &  str )

inlineprivate

Definition at line 193 of file DicomPhantomZSliceHeader.hh.

{
  std::istringstream iss(str);
  T val;
  iss >> val;
  return val;
}

CheckConsistency()

template<typename T >

bool DicomPhantomZSliceHeader::CheckConsistency ( const T &  val1, const T &  val2, G4String  category  )

inlineprivate

Definition at line 203 of file DicomPhantomZSliceHeader.hh.

                                                                          {
  if(val1 != val2) {
    G4Exception("DicomPhantomSliceZHeader::CheckConsistency", 
                "Consistency Mismatch : Keeping previous value if nonzero",
                JustWarning, category.c_str());
        return false;
  }
  return true;
}

CheckMaterialExists()

G4bool DicomPhantomZSliceHeader::CheckMaterialExists ( const G4String &  mateName )

private

Definition at line 106 of file DicomPhantomZSliceHeader.cc.

{
    const G4MaterialTable* matTab = G4Material::GetMaterialTable();
    std::vector<G4Material*>::const_iterator matite;
    for( matite = matTab->begin(); matite != matTab->end(); ++matite ) {
        if( (*matite)->GetName() == mateName ) { return true; }
    }
 
    G4Material* g4mate = G4NistManager::Instance()->FindOrBuildMaterial(mateName);
    if( g4mate ) {
      return false;
    } else {
      return true;
    }
 
}

Member Data Documentation

fNoVoxelsX

G4int DicomPhantomZSliceHeader::fNoVoxelsX

private

Definition at line 165 of file DicomPhantomZSliceHeader.hh.

fNoVoxelsY

G4int DicomPhantomZSliceHeader::fNoVoxelsY

private

Definition at line 165 of file DicomPhantomZSliceHeader.hh.

fNoVoxelsZ

G4int DicomPhantomZSliceHeader::fNoVoxelsZ

private

Definition at line 165 of file DicomPhantomZSliceHeader.hh.

fMinX

G4double DicomPhantomZSliceHeader::fMinX

private

Definition at line 166 of file DicomPhantomZSliceHeader.hh.

fMinY

G4double DicomPhantomZSliceHeader::fMinY

private

Definition at line 166 of file DicomPhantomZSliceHeader.hh.

fMinZ

G4double DicomPhantomZSliceHeader::fMinZ

private

Definition at line 166 of file DicomPhantomZSliceHeader.hh.

fMaxX

G4double DicomPhantomZSliceHeader::fMaxX

private

Definition at line 167 of file DicomPhantomZSliceHeader.hh.

fMaxY

G4double DicomPhantomZSliceHeader::fMaxY

private

Definition at line 167 of file DicomPhantomZSliceHeader.hh.

fMaxZ

G4double DicomPhantomZSliceHeader::fMaxZ

private

Definition at line 167 of file DicomPhantomZSliceHeader.hh.

fMaterialNames

std::vector<G4String> DicomPhantomZSliceHeader::fMaterialNames

private

Definition at line 169 of file DicomPhantomZSliceHeader.hh.

fFilename

G4String DicomPhantomZSliceHeader::fFilename

private

Definition at line 171 of file DicomPhantomZSliceHeader.hh.

fValues

std::vector<std::vector<G4double> > DicomPhantomZSliceHeader::fValues

private

Definition at line 172 of file DicomPhantomZSliceHeader.hh.

fMateIDs

std::vector<std::vector<G4int> > DicomPhantomZSliceHeader::fMateIDs

private

Definition at line 173 of file DicomPhantomZSliceHeader.hh.

fSliceLocation

G4double DicomPhantomZSliceHeader::fSliceLocation

private

Definition at line 174 of file DicomPhantomZSliceHeader.hh.

---

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

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