DicomPhantomZSliceMerged Class Reference

#include <DicomPhantomZSliceMerged.hh>

Public Member Functions
	DicomPhantomZSliceMerged ()
	~DicomPhantomZSliceMerged ()
void	AddZSlice (DicomPhantomZSliceHeader *val)
void	CheckSlices ()
void	DumpExcessMemory ()

Detailed Description

Definition at line 47 of file DicomPhantomZSliceMerged.hh.

Constructor & Destructor Documentation

DicomPhantomZSliceMerged::DicomPhantomZSliceMerged

(

)

Definition at line 48 of file DicomPhantomZSliceMerged.cc.

{

}

DicomPhantomZSliceMerged::~DicomPhantomZSliceMerged

(

)

Definition at line 56 of file DicomPhantomZSliceMerged.cc.

{
    fSlices.clear();
}

Member Function Documentation

void DicomPhantomZSliceMerged::AddZSlice ( DicomPhantomZSliceHeader *  val )

inline

Definition at line 56 of file DicomPhantomZSliceMerged.hh.

References DicomPhantomZSliceHeader::GetSliceLocation().

Referenced by DicomHandler::ReadFile().

                                                  {
        fSlices[val->GetSliceLocation()] = val;
        //std::cout << "Slice Location : " << val->GetSliceLocation()/mm << " mm" << std::endl;
    }

void DicomPhantomZSliceMerged::CheckSlices

(

)

Definition at line 63 of file DicomPhantomZSliceMerged.cc.

References G4cout, G4endl, DicomPhantomZSliceHeader::GetMaxZ(), DicomPhantomZSliceHeader::GetMinZ(), DicomPhantomZSliceHeader::GetSliceLocation(), python.hepunit::mm, DicomPhantomZSliceHeader::SetMaxZ(), and DicomPhantomZSliceHeader::SetMinZ().

Referenced by DicomHandler::CheckFileFormat().

{
    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 {
            std::map<G4double,DicomPhantomZSliceHeader*>::iterator ite0 = fSlices.begin();
            std::map<G4double,DicomPhantomZSliceHeader*>::iterator ite1 = fSlices.begin();
            std::map<G4double,DicomPhantomZSliceHeader*>::iterator 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) {
                    unsigned int 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;

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


}

void DicomPhantomZSliceMerged::DumpExcessMemory ( )

inline

Definition at line 75 of file DicomPhantomZSliceMerged.hh.

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

---

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

• DicomPhantomZSliceMerged.hh
• DicomPhantomZSliceMerged.cc