#include <Doxymodules_medical.h>

Public Member Functions
	DicomPhantomZSliceMerged ()

	~DicomPhantomZSliceMerged ()

void	AddZSlice (DicomPhantomZSliceHeader *val)

void	CheckSlices ()

void	DumpExcessMemory ()

Private Attributes
std::map< G4double, DicomPhantomZSliceHeader * >	fSlices

Detailed Description

Definition at line 28 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

◆ DicomPhantomZSliceMerged()

DicomPhantomZSliceMerged::DicomPhantomZSliceMerged ( )

Definition at line 46 of file DicomPhantomZSliceMerged.cc.

{
 
}

◆ ~DicomPhantomZSliceMerged()

DicomPhantomZSliceMerged::~DicomPhantomZSliceMerged ( )

Definition at line 53 of file DicomPhantomZSliceMerged.cc.

{
    fSlices.clear();
}

Member Function Documentation

◆ AddZSlice()

void DicomPhantomZSliceMerged::AddZSlice ( DicomPhantomZSliceHeader * val )

inline

Definition at line 55 of file DicomPhantomZSliceMerged.hh.

                                                  {
        fSlices[val->GetSliceLocation()] = val;
    }

◆ CheckSlices()

void DicomPhantomZSliceMerged::CheckSlices ( )

Definition at line 60 of file DicomPhantomZSliceMerged.cc.

{
  G4cout << "\nDicomPhantomZSliceMerged::Checking "
         << fSlices.size() << " fSlices..." << G4endl;
  
  G4bool uniformSliceThickness = true;
  
  if(fSlices.size() > 1) {
    if(fSlices.size() == 2) {
      DicomPhantomZSliceHeader* one = fSlices.begin()->second;
      DicomPhantomZSliceHeader* two = fSlices.end()->second;
      
      G4double real_distance = (two->GetSliceLocation()-one->GetSliceLocation())/2.;
      
      if(one->GetMaxZ() != two->GetMinZ()) {
        one->SetMaxZ(one->GetSliceLocation()+real_distance);
        two->SetMinZ(two->GetSliceLocation()-real_distance);
        //one->SetMinZ(one->GetSliceLocation()-real_distance);
        //two->SetMaxZ(two->GetSliceLocation()+real_distance);
        if(uniformSliceThickness) {
          one->SetMinZ(one->GetSliceLocation()-real_distance);
          two->SetMaxZ(two->GetSliceLocation()+real_distance);
        }
      }
    } else {
      auto ite0 = fSlices.begin();
      auto ite1 = fSlices.begin();
      auto ite2 = fSlices.begin();
      ++ite1;
      ++ite2; ++ite2;
      
      for(; ite2 != fSlices.end(); ++ite0, ++ite1, ++ite2)
      {
        DicomPhantomZSliceHeader* prev = ite0->second;
        DicomPhantomZSliceHeader* slice = ite1->second;
        DicomPhantomZSliceHeader* next = ite2->second;
        G4double real_max_distance = (next->GetSliceLocation() -
                                      slice->GetSliceLocation())/2.;
        G4double real_min_distance = (slice->GetSliceLocation() -
                                      prev->GetSliceLocation())/2.;
        G4double real_distance = real_max_distance + real_min_distance;
        G4double stated_distance = slice->GetMaxZ()-slice->GetMinZ();
        if(real_distance != stated_distance) {
          uintmax_t sliceNum = std::distance(fSlices.begin(),ite1);
          G4cout << "\tDicomPhantomZSliceMerged::CheckSlices - \
                    Slice Distance Error in slice [" << sliceNum 
                 << "]: Real Distance = "
                 << real_distance/mm
                 << " mm, Stated Distance = " << stated_distance/mm << G4endl;
          slice->SetMinZ(slice->GetSliceLocation()-real_min_distance);
          slice->SetMaxZ(slice->GetSliceLocation()+real_max_distance);
          
          if(ite0 == fSlices.begin()) {
            prev->SetMaxZ(slice->GetMinZ());
            // Using below would make all slice same thickness
            //prev->SetMinZ(prev->GetSliceLocation()-real_min_distance);
            if(uniformSliceThickness) {
              prev->SetMinZ(prev->GetSliceLocation()-real_min_distance); }
            
          }
          if(static_cast<unsigned int>(std::distance(fSlices.begin(),ite2)+1)==
             fSlices.size()) {
            next->SetMinZ(slice->GetMaxZ());
            // Using below would make all slice same thickness
            //next->SetMaxZ(next->GetSliceLocation()+real_max_distance);
            if(uniformSliceThickness) {
              next->SetMaxZ(next->GetSliceLocation()+real_max_distance); }
          }
        }
      }
    }
  }
  G4cout << G4endl;
  
  for(auto ite = fSlices.cbegin(); ite != fSlices.cend(); ++ite) {
    ite->second->DumpToFile();
  }
  
}

◆ DumpExcessMemory()

void DicomPhantomZSliceMerged::DumpExcessMemory ( )

inline

Definition at line 73 of file DicomPhantomZSliceMerged.hh.

{
    for(std::map<G4double,DicomPhantomZSliceHeader*>::iterator ite = fSlices.begin();
        ite != fSlices.end(); ++ite) {
        ite->second->DumpExcessMemory();
    }
}