#include <G4GMocrenIO.hh>

Public Member Functions
void	addDetector (std::string &_name, std::vector< float * > &_det, unsigned char _color[3])

bool	addDoseDist (std::vector< double * > &_image, int _num=0)

void	addOneEvent ()

void	addPointerToDoseDistData (unsigned int &_pointer)

void	addTrack (float *_tracks)

void	addTrack (std::vector< float * > &_steps, unsigned char _color[3])

void	addTrackColor (unsigned char *_colors)

void	clearDetector ()

void	clearDoseDistAll ()

void	clearModalityImage ()

void	clearROIAll ()

void	clearTracks ()

short	convertDensityToHU (float &_dens)

template<typename T >
void	convertEndian (char *_val, T &_rval)

void	copyDoseDist (std::vector< class GMocrenDataPrimitive< double > > &_dose)

void	copyTracks (std::vector< float * > &_tracks, std::vector< unsigned char * > &_colors)

	G4GMocrenIO ()

std::string &	getComment ()

void	getDetector (int _num, std::vector< float * > &_edges, std::vector< unsigned char * > &_color, std::string &_detectorName)

double *	getDoseDist (int _z, int _num=0)

void	getDoseDistCenterPosition (float _center[3], int _num=0)

void	getDoseDistMinMax (double _minmax[2], int _num=0)

void	getDoseDistMinMax (short _minmax[2], int _num=0)

std::string	getDoseDistName (int _num=0)

double	getDoseDistScale (int _num=0)

void	getDoseDistSize (int _size[3], int _num=0)

std::string	getDoseDistUnit (int _num=0)

std::string &	getFileName ()

std::string &	getID ()

void	getModalityCenterPosition (float _center[3])

short *	getModalityImage (int _z)

std::vector< float > &	getModalityImageDensityMap ()

short	getModalityImageMax ()

short	getModalityImageMin ()

void	getModalityImageMinMax (short _minmax[2])

double	getModalityImageScale ()

void	getModalityImageSize (int _size[3])

std::string	getModalityImageUnit ()

void	getModalityImageVoxelSpacing (float _size[3])

int	getNumberOfDetectors ()

int &	getNumberOfEvents ()

int	getNumDoseDist ()

int	getNumROI ()

int	getNumTracks ()

int	getNumTracks4 ()

unsigned int	getPointerToDoseDistData (int _elem=0)

unsigned int	getPointerToModalityData ()

unsigned int	getPointerToROIData ()

unsigned int	getPointerToTrackData ()

short *	getROI (int _z, int _num=0)

void	getROICenterPosition (float _center[3], int _num=0)

void	getROIMinMax (short _minmax[2], int _num=0)

double	getROIScale (int _num=0)

void	getROISize (int _size[3], int _num=0)

void	getShortDoseDist (short *_data, int _z, int _num=0)

void	getShortDoseDistMinMax (short _minmax[2], int _num=0)

void	getTrack (int _num, std::vector< float * > &_steps, std::vector< unsigned char * > &_color)

std::vector< unsigned char * > &	getTrackColors ()

std::vector< float * > &	getTracks ()

std::string &	getVersion ()

void	getVoxelSpacing (float _spacing[3])

void	initialize ()

bool	mergeDoseDist (std::vector< class GMocrenDataPrimitive< double > > &_dose)

void	mergeTracks (std::vector< float * > &_tracks, std::vector< unsigned char * > &_colors)

void	newDoseDist ()

void	newROI ()

void	notStoredTracks ()

bool	retrieveData ()

bool	retrieveData (char *_filename)

bool	retrieveData2 ()

bool	retrieveData2 (char *_filename)

bool	retrieveData3 ()

bool	retrieveData3 (char *_filename)

bool	retrieveData4 ()

bool	retrieveData4 (char *_filename)

void	setComment (std::string &_comment)

void	setDoseDist (double *_image, int _num=0)

void	setDoseDistCenterPosition (float _center[3], int _num=0)

void	setDoseDistMinMax (double _minmax[2], int _num=0)

void	setDoseDistMinMax (short _minmax[2], int _num=0)

void	setDoseDistName (std::string _name, int _num=0)

void	setDoseDistScale (double &_scale, int _num=0)

void	setDoseDistSize (int _size[3], int _num=0)

void	setDoseDistUnit (std::string &_unit, int _num=0)

void	setFileName (char *_filename)

void	setFileName (std::string &_filename)

void	setID ()

void	setID (std::string &_id)

void	setLittleEndianInput (bool _little)

void	setLittleEndianOutput (bool _little)

void	setModalityCenterPosition (float _center[3])

void	setModalityImage (short *_image)

void	setModalityImageDensityMap (std::vector< float > &_map)

void	setModalityImageMinMax (short _minmax[2])

void	setModalityImageScale (double &_scale)

void	setModalityImageSize (int _size[3])

void	setModalityImageUnit (std::string &_unit)

void	setModalityImageVoxelSpacing (float _size[3])

void	setNumberOfEvents (int &_numberOfEvents)

void	setPointerToModalityData (unsigned int &_pointer)

void	setPointerToROIData (unsigned int &_pointer)

void	setPointerToTrackData (unsigned int &_pointer)

void	setROI (short *_image, int _num=0)

void	setROICenterPosition (float _center[3], int _num=0)

void	setROIMinMax (short _minmax[2], int _num=0)

void	setROIScale (double &_scale, int _num=0)

void	setROISize (int _size[3], int _num=0)

void	setShortDoseDist (short *_image, int _num=0)

void	setTrackColors (std::vector< unsigned char * > &_trackColors)

void	setTracks (std::vector< float * > &_tracks)

void	setVerboseLevel (int _level)

void	setVersion (std::string &_version)

void	setVoxelSpacing (float _spacing[3])

bool	storeData ()

bool	storeData (char *_filename)

bool	storeData2 ()

bool	storeData2 (char *_filename)

bool	storeData3 ()

bool	storeData3 (char *_filename)

bool	storeData4 ()

bool	storeData4 (char *_filename)

void	translateDetector (std::vector< float > &_translate)

void	translateTracks (std::vector< float > &_translateo)

	~G4GMocrenIO ()

Data Fields
bool	kTracksWillBeStored

Static Public Attributes
static std::string	kComment

static std::vector< class GMocrenDetector >	kDetectors

static std::vector< class GMocrenDataPrimitive< double > >	kDose

static std::string	kDoseUnit = "keV "

static std::string	kFileName = "dose.gdd"

static std::string	kId

static char	kLittleEndianInput = true

static char	kLittleEndianOutput = true

static class GMocrenDataPrimitive< short >	kModality

static std::vector< float >	kModalityImageDensityMap

static std::string	kModalityUnit = "g/cm3 "

static int	kNumberOfEvents = 0

static unsigned int	kPointerToDetectorData = 0

static std::vector< unsigned int >	kPointerToDoseDistData

static unsigned int	kPointerToModalityData = 0

static unsigned int	kPointerToROIData = 0

static unsigned int	kPointerToTrackData = 0

static std::vector< class GMocrenDataPrimitive< short > >	kRoi

static std::vector< unsigned char * >	kStepColors

static std::vector< float * >	kSteps

static std::vector< class GMocrenTrack >	kTracks

static int	kVerbose = 0

static std::string	kVersion = "2.0.0"

static float	kVoxelSpacing [3] = {0., 0., 0.}

Protected Member Functions
void	calcDoseDistScale ()

template<typename Type >
void	convertEndian (char *, Type &)

template<typename T >
void	invertByteOrder (char *_val, T &_rval)

bool	isDoseEmpty ()

bool	isROIEmpty ()

Private Member Functions
void	calcPointers2 ()

void	calcPointers3 ()

void	calcPointers4 ()

Detailed Description

Definition at line 166 of file G4GMocrenIO.hh.

Constructor & Destructor Documentation

◆ G4GMocrenIO()

G4GMocrenIO::G4GMocrenIO ( )

Definition at line 401 of file G4GMocrenIO.cc.

  : kTracksWillBeStored(true) {
  ;
}

◆ ~G4GMocrenIO()

G4GMocrenIO::~G4GMocrenIO ( )

Definition at line 407 of file G4GMocrenIO.cc.

                          {
  ;
}

Member Function Documentation

◆ addDetector()

void G4GMocrenIO::addDetector	(	std::string &	_name,
		std::vector< float * > &	_det,
		unsigned char	_color[3]
	)

Definition at line 3948 of file G4GMocrenIO.cc.

                                         {
 
    std::vector<float *>::iterator itr = _det.begin();
    std::vector<struct GMocrenDetector::Edge> edges;
    for(; itr != _det.end(); itr++) {
      struct GMocrenDetector::Edge edge;
      for(int i = 0; i < 3; i++) {
    edge.startPoint[i] = (*itr)[i];
    edge.endPoint[i] = (*itr)[i+3];
      }
      edges.push_back(edge);
    }
    GMocrenDetector detector;
    detector.setDetector(edges);
    detector.setColor(_color);
    detector.setName(_name);
    kDetectors.push_back(detector);
    
}

References GMocrenDetector::Edge::endPoint, kDetectors, GMocrenDetector::setColor(), GMocrenDetector::setDetector(), GMocrenDetector::setName(), and GMocrenDetector::Edge::startPoint.

Referenced by G4GMocrenFileSceneHandler::ExtractDetector(), and retrieveData4().

◆ addDoseDist()

bool G4GMocrenIO::addDoseDist	(	std::vector< double * > &	_image,
		int	_num = `0`
	)

Definition at line 3633 of file G4GMocrenIO.cc.

                                                                    {
 
  int size[3];
  getDoseDistSize(size, _num);
  std::vector<double *> dosedist = kDose[_num].getImage();
 
  int nimg = size[0]*size[1];
  for(int z = 0; z < size[2]; z++) {
    for(int xy = 0; xy < nimg; xy++) {
      dosedist[z][xy] += _image[z][xy];
    }
  }
 
  return true;
}

References getDoseDistSize(), and kDose.

◆ addOneEvent()

void G4GMocrenIO::addOneEvent ( )

Definition at line 3142 of file G4GMocrenIO.cc.

                              {
  kNumberOfEvents++;
}

References kNumberOfEvents.

◆ addPointerToDoseDistData()

void G4GMocrenIO::addPointerToDoseDistData ( unsigned int & _pointer )

Definition at line 3154 of file G4GMocrenIO.cc.

                                                                  {
  kPointerToDoseDistData.push_back(_pointer);
}

References kPointerToDoseDistData.

Referenced by calcPointers3(), calcPointers4(), retrieveData3(), and retrieveData4().

◆ addTrack() [1/2]

void G4GMocrenIO::addTrack ( float * _tracks )

Definition at line 3841 of file G4GMocrenIO.cc.

                                          {
  kSteps.push_back(_tracks);
}

References kSteps.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::EndSavingGdd(), mergeTracks(), retrieveData2(), retrieveData3(), and retrieveData4().

◆ addTrack() [2/2]

void G4GMocrenIO::addTrack	(	std::vector< float * > &	_steps,
		unsigned char	_color[3]
	)

Definition at line 3891 of file G4GMocrenIO.cc.

                                                                               {
 
  std::vector<float *>::iterator itr = _steps.begin();
    std::vector<struct GMocrenTrack::Step> steps;
    for(; itr != _steps.end(); itr++) {
      struct GMocrenTrack::Step step;
      for(int i = 0; i < 3; i++) {
    step.startPoint[i] = (*itr)[i];
    step.endPoint[i] = (*itr)[i+3];
      }
      steps.push_back(step);
    }
    GMocrenTrack track;
    track.setTrack(steps);
    track.setColor(_color);
    kTracks.push_back(track);
    
}

References GMocrenTrack::Step::endPoint, kTracks, GMocrenTrack::setColor(), GMocrenTrack::setTrack(), and GMocrenTrack::Step::startPoint.

◆ addTrackColor()

void G4GMocrenIO::addTrackColor ( unsigned char * _colors )

Definition at line 3850 of file G4GMocrenIO.cc.

                                                       {
  kStepColors.push_back(_colors);
}

References kStepColors.

Referenced by mergeTracks(), and retrieveData3().

◆ calcDoseDistScale()

void G4GMocrenIO::calcDoseDistScale ( )

protected

Definition at line 3726 of file G4GMocrenIO.cc.

                                    {
 
  double scale;
  double minmax[2];
 
  for(int i = 0; i < (int)kDose.size(); i++) {
    kDose[i].getMinMax(minmax);
    scale = minmax[1]/DOSERANGE;
    kDose[i].setScale(scale);
  }
}

References DOSERANGE, and kDose.

Referenced by storeData2(), storeData3(), and storeData4().

◆ calcPointers2()

void G4GMocrenIO::calcPointers2 ( )

private

Definition at line 3310 of file G4GMocrenIO.cc.

                                {
 
  // pointer to modality data
  unsigned int pointer = 65;
  setPointerToModalityData(pointer);
 
  // pointer to dose data
  int msize[3];
  getModalityImageSize(msize);
  short mminmax[2];
  getModalityImageMinMax(mminmax);
  int pmsize = 2*msize[0]*msize[1]*msize[2];
  int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
  pointer += 20 + pmsize + pmmap;
  int dsize[3];
  getDoseDistSize(dsize);
  kPointerToDoseDistData.clear();
  if(dsize[0] != 0) {
    kPointerToDoseDistData.push_back(pointer);
 
    int pdsize = 2*dsize[0]*dsize[1]*dsize[2];
    pointer += 20 + pdsize + 12;
  } else {
    unsigned int pointer0 = 0;
    kPointerToDoseDistData.push_back(pointer0);
  }
 
  // pointer to roi data
  if(!isROIEmpty())  {
    int rsize[3];
    getROISize(rsize);
    setPointerToROIData(pointer);
    int prsize = 2*rsize[0]*rsize[1]*rsize[2];
    pointer += 20 + prsize + 12;
 
  } else {
    unsigned int pointer0 = 0;
    setPointerToROIData(pointer0);
  }
 
  //
  if(getNumTracks() != 0) 
    setPointerToTrackData(pointer);
  else {
    unsigned int pointer0 = 0;
    setPointerToTrackData(pointer0);
  }
 
}

References getDoseDistSize(), getModalityImageMinMax(), getModalityImageSize(), getNumTracks(), getROISize(), isROIEmpty(), kPointerToDoseDistData, setPointerToModalityData(), setPointerToROIData(), and setPointerToTrackData().

Referenced by storeData2().

◆ calcPointers3()

void G4GMocrenIO::calcPointers3 ( )

private

Definition at line 3255 of file G4GMocrenIO.cc.

                                {
 
  // pointer to modality data
  unsigned int pointer = 1066; // up to "pointer to the track data" except for "pointer to the dose dist data"
  int nDoseDist = getNumDoseDist();
  pointer += nDoseDist*4;
 
  setPointerToModalityData(pointer);
 
  // pointer to dose data
  // ct-density map for modality data
  int msize[3];
  getModalityImageSize(msize);
  short mminmax[2];
  getModalityImageMinMax(mminmax);
  int pmsize = 2*msize[0]*msize[1]*msize[2];
  int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
  pointer += 32 + pmsize + pmmap;
  //
  kPointerToDoseDistData.clear();
  if(nDoseDist == 0) {
    unsigned int pointer0 = 0;
    addPointerToDoseDistData(pointer0);
  }
  for(int ndose = 0; ndose < nDoseDist; ndose++) {
    addPointerToDoseDistData(pointer);
    int dsize[3];
    getDoseDistSize(dsize);
    pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2;
  }
 
  // pointer to roi data
  if(!isROIEmpty()) {
    setPointerToROIData(pointer);
    
    int rsize[3];
    getROISize(rsize);
    int prsize = 2*rsize[0]*rsize[1]*rsize[2];
    pointer += 20 + prsize + 12;
  } else {
    unsigned int pointer0 = 0;
    setPointerToROIData(pointer0);
  }
 
  //
  if(getNumTracks() != 0) 
    setPointerToTrackData(pointer);
  else {
    unsigned int pointer0 = 0;
    setPointerToTrackData(pointer0);
  }
 
}

References addPointerToDoseDistData(), getDoseDistSize(), getModalityImageMinMax(), getModalityImageSize(), getNumDoseDist(), getNumTracks(), getROISize(), isROIEmpty(), kPointerToDoseDistData, setPointerToModalityData(), setPointerToROIData(), and setPointerToTrackData().

Referenced by storeData3().

◆ calcPointers4()

void G4GMocrenIO::calcPointers4 ( )

private

Definition at line 3181 of file G4GMocrenIO.cc.

                                {
 
  // pointer to modality data
  unsigned int pointer = 1070; // up to "pointer to the detector data" except for "pointer to the dose dist data"
  int nDoseDist = getNumDoseDist();
  pointer += nDoseDist*4;
 
  setPointerToModalityData(pointer);
 
  // pointer to dose data
  // ct-density map for modality data
  int msize[3];
  getModalityImageSize(msize);
  short mminmax[2];
  getModalityImageMinMax(mminmax);
  int pmsize = 2*msize[0]*msize[1]*msize[2];
  int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
  pointer += 32 + pmsize + pmmap;
  //
  kPointerToDoseDistData.clear();
  if(nDoseDist == 0) {
    unsigned int pointer0 = 0;
    addPointerToDoseDistData(pointer0);
  }
  for(int ndose = 0; ndose < nDoseDist; ndose++) {
    addPointerToDoseDistData(pointer);
    int dsize[3];
    getDoseDistSize(dsize);
    pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2 + 80;
  }
 
  // pointer to roi data
  if(!isROIEmpty()) {
    setPointerToROIData(pointer);
    
    int rsize[3];
    getROISize(rsize);
    int prsize = 2*rsize[0]*rsize[1]*rsize[2];
    pointer += 20 + prsize + 12;
  } else {
    unsigned int pointer0 = 0;
    setPointerToROIData(pointer0);
  }
 
  // pointer to track data
  int ntrk = kTracks.size();
  if(ntrk != 0) {
    setPointerToTrackData(pointer);
 
    pointer += 4; // # of tracks
    for(int nt = 0; nt < ntrk; nt++) {
      int nsteps = kTracks[nt].getNumberOfSteps();
      pointer += 4 + 3 + nsteps*(4*6); // # of steps + color + steps(float*6)
    }
  } else {
    unsigned int pointer0 = 0;
    setPointerToTrackData(pointer0);
  }
  if(kVerbose > 0) G4cout << " pointer to the track data :"
                 << kPointerToTrackData << G4endl;
 
  // pointer to detector data
  int ndet = kDetectors.size();
  if(ndet != 0) {
    kPointerToDetectorData = pointer;
  } else {
    kPointerToDetectorData = 0;
  }
  if(kVerbose > 0) G4cout << " pointer to the detector data :"
                 << kPointerToDetectorData << G4endl;
 
}

References addPointerToDoseDistData(), G4cout, G4endl, getDoseDistSize(), getModalityImageMinMax(), getModalityImageSize(), getNumDoseDist(), getROISize(), isROIEmpty(), kDetectors, kPointerToDetectorData, kPointerToDoseDistData, kPointerToTrackData, kTracks, kVerbose, setPointerToModalityData(), setPointerToROIData(), and setPointerToTrackData().

Referenced by storeData4().

◆ clearDetector()

void G4GMocrenIO::clearDetector ( )

inline

Definition at line 451 of file G4GMocrenIO.hh.

451{kDetectors.clear();}

References kDetectors.

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ clearDoseDistAll()

void G4GMocrenIO::clearDoseDistAll ( )

Definition at line 3705 of file G4GMocrenIO.cc.

                                   {
 
  if(!isDoseEmpty()) {
    for(int i = 0; i < getNumDoseDist(); i++) {
      kDose[i].clear();
    }
    kDose.clear();
  }
}

References getNumDoseDist(), isDoseEmpty(), and kDose.

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ clearModalityImage()

void G4GMocrenIO::clearModalityImage ( )

Definition at line 3390 of file G4GMocrenIO.cc.

                                     {
  
  kModality.clearImage();
}

References GMocrenDataPrimitive< T >::clearImage(), and kModality.

◆ clearROIAll()

void G4GMocrenIO::clearROIAll ( )

Definition at line 3811 of file G4GMocrenIO.cc.

                              {
 
  if(!isROIEmpty()) {
    for(int i = 0; i < getNumROI(); i++) {
      kRoi[i].clear();
    }
    kRoi.clear();
  }
}

References getNumROI(), isROIEmpty(), and kRoi.

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ clearTracks()

void G4GMocrenIO::clearTracks ( )

inline

Definition at line 439 of file G4GMocrenIO.hh.

439{kTracks.clear();}

References kTracks.

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ convertDensityToHU()

short G4GMocrenIO::convertDensityToHU ( float & _dens )

Definition at line 3445 of file G4GMocrenIO.cc.

                                                   {
  short rval = -1024; // default: air
  int nmap = (int)kModalityImageDensityMap.size();
  if(nmap != 0) {
    short minmax[2];
    kModality.getMinMax(minmax);
    rval = minmax[1];
    for(int i = 0; i < nmap; i++) {
      //G4cout << kModalityImageDensityMap[i] << G4endl;
      if(_dens <= kModalityImageDensityMap[i]) {
    rval = i + minmax[0];
    break;
      }
    }
  }
  return rval;
}

References GMocrenDataPrimitive< T >::getMinMax(), kModality, and kModalityImageDensityMap.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ convertEndian() [1/2]

template<typename Type >

void G4GMocrenIO::convertEndian	(	char *	,
		Type &
	)

protected

Referenced by retrieveData2(), retrieveData3(), and retrieveData4().

◆ convertEndian() [2/2]

template<typename T >

void G4GMocrenIO::convertEndian	(	char *	_val,
		T &	_rval
	)

Definition at line 4009 of file G4GMocrenIO.cc.

                                                      {
 
  if((kLittleEndianOutput && !kLittleEndianInput) ||   // big endian
     (!kLittleEndianOutput && kLittleEndianInput)) {   // little endian
 
    const int SIZE = sizeof(_rval);
    char ctemp;
    for(int i = 0; i < SIZE/2; i++) {
      ctemp = _val[i];
      _val[i] = _val[SIZE - 1 - i];
      _val[SIZE - 1 - i] = ctemp;
    }
  }
  _rval = *(T *)_val;
}

References kLittleEndianInput, and kLittleEndianOutput.

◆ copyDoseDist()

void G4GMocrenIO::copyDoseDist ( std::vector< class GMocrenDataPrimitive< double > > & _dose )

Definition at line 3675 of file G4GMocrenIO.cc.

                                                                                     {
  std::vector<class GMocrenDataPrimitive<double> >::iterator itr;
  for(itr = kDose.begin(); itr != kDose.end(); itr++) {
    _dose.push_back(*itr);
  }
}

References kDose.

◆ copyTracks()

void G4GMocrenIO::copyTracks	(	std::vector< float * > &	_tracks,
		std::vector< unsigned char * > &	_colors
	)

Definition at line 3859 of file G4GMocrenIO.cc.

                                                         {
  std::vector<float *>::iterator titr;
  for(titr = kSteps.begin(); titr != kSteps.end(); titr++) {
    float * pts = new float[6];
    for(int i = 0; i < 6; i++) {
      pts[i] = (*titr)[i];
    }
    _tracks.push_back(pts);
  }
 
  std::vector<unsigned char *>::iterator citr;
  for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++) {
    unsigned char * pts = new unsigned char[3];
    for(int i = 0; i < 3; i++) {
      pts[i] = (*citr)[i];
    }
    _colors.push_back(pts);
  }
}

References kStepColors, and kSteps.

◆ getComment()

std::string & G4GMocrenIO::getComment ( )

inline

Definition at line 274 of file G4GMocrenIO.hh.

274{return kComment;}

G4GMocrenIO::kComment

static std::string kComment

Definition: G4GMocrenIO.hh:181

References kComment.

◆ getDetector()

void G4GMocrenIO::getDetector	(	int	_num,
		std::vector< float * > &	_edges,
		std::vector< unsigned char * > &	_color,
		std::string &	_detectorName
	)

Definition at line 3970 of file G4GMocrenIO.cc.

                                      {
 
  if(_num > (int)kDetectors.size()) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "ERROR in getDetector() : " << G4endl;
    
    G4Exception("G4GMocrenIO::getDetector()",
                "gMocren2004", FatalException,
                "Error.");
  }
 
  _detName = kDetectors[_num].getName();
 
  unsigned char * color = new unsigned char[3];
  kDetectors[_num].getColor(color);
  _color.push_back(color);
 
  // edges
  int nedges = kDetectors[_num].getNumberOfEdges();
  for(int ne = 0; ne < nedges; ne++) {
    float * edgePoints = new float[6];
    kDetectors[_num].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
                 edgePoints[3], edgePoints[4], edgePoints[5],
                 ne);
    _edges.push_back(edgePoints);
  }
}

References G4VisManager::errors, FatalException, G4cout, G4endl, G4Exception(), G4VisManager::GetVerbosity(), and kDetectors.

◆ getDoseDist()

double * G4GMocrenIO::getDoseDist	(	int	_z,
		int	_num = `0`
	)

Definition at line 3610 of file G4GMocrenIO.cc.

                                                  {
 
  double * image;
  if(isDoseEmpty()) {
    image = 0;
  } else {
    image = kDose[_num].getImage(_z);
  }
  return image;
}

References isDoseEmpty(), and kDose.

◆ getDoseDistCenterPosition()

void G4GMocrenIO::getDoseDistCenterPosition	(	float	_center[3],
		int	_num = `0`
	)

Definition at line 3654 of file G4GMocrenIO.cc.

                                                                      {
 
  if(isDoseEmpty())
    for(int i = 0; i < 3; i++) _center[i] = 0;
  else 
    kDose[_num].getCenterPosition(_center);
}

References isDoseEmpty(), and kDose.

Referenced by storeData3(), and storeData4().

◆ getDoseDistMinMax() [1/2]

void G4GMocrenIO::getDoseDistMinMax	(	double	_minmax[2],
		int	_num = `0`
	)

Definition at line 3526 of file G4GMocrenIO.cc.

                                                               {
 
  if(isDoseEmpty())
    for(int i = 0; i < 2; i++) _minmax[i] = 0.;
  else
    kDose[_num].getMinMax(_minmax);
}  

References isDoseEmpty(), and kDose.

◆ getDoseDistMinMax() [2/2]

void G4GMocrenIO::getDoseDistMinMax	(	short	_minmax[2],
		int	_num = `0`
	)

Definition at line 3511 of file G4GMocrenIO.cc.

                                                              {
 
  if(isDoseEmpty())
    for(int i = 0; i < 2; i++) _minmax[i] = 0;
  else {
    double minmax[2];
    kDose[_num].getMinMax(minmax);
    double scale = kDose[_num].getScale();
    for(int i = 0; i < 2; i++) _minmax[i] = (short)(minmax[i]/scale+0.5);
  }
}  

References isDoseEmpty(), and kDose.

◆ getDoseDistName()

std::string G4GMocrenIO::getDoseDistName ( int _num = 0 )

Definition at line 3666 of file G4GMocrenIO.cc.

                                               {
 
  std::string name;
  if(isDoseEmpty())
    return name;
  else 
    return kDose[_num].getName();
}

References isDoseEmpty(), kDose, and G4InuclParticleNames::name().

Referenced by storeData4().

◆ getDoseDistScale()

double G4GMocrenIO::getDoseDistScale ( int _num = 0 )

Definition at line 3539 of file G4GMocrenIO.cc.

                                             {
 
  if(isDoseEmpty())
    return 0.;
  else 
    return kDose[_num].getScale();
}

References isDoseEmpty(), and kDose.

Referenced by storeData3(), and storeData4().

◆ getDoseDistSize()

void G4GMocrenIO::getDoseDistSize	(	int	_size[3],
		int	_num = `0`
	)

Definition at line 3491 of file G4GMocrenIO.cc.

                                                        {
  if(isDoseEmpty())
    for(int i = 0; i < 3; i++) _size[i] = 0;
  else 
    kDose[_num].getSize(_size);
}

References isDoseEmpty(), and kDose.

Referenced by addDoseDist(), calcPointers2(), calcPointers3(), and calcPointers4().

◆ getDoseDistUnit()

std::string G4GMocrenIO::getDoseDistUnit ( int _num = 0 )

Definition at line 3475 of file G4GMocrenIO.cc.

                                               {
  // to avoid a warning in the compile process
  if(kDoseUnit.size() > static_cast<size_t>(_num)) return kDoseUnit;
 
  return kDoseUnit;
}

References kDoseUnit.

◆ getFileName()

std::string & G4GMocrenIO::getFileName ( )

inline

Definition at line 240 of file G4GMocrenIO.hh.

240{return kFileName;}

G4GMocrenIO::kFileName

static std::string kFileName

Definition: G4GMocrenIO.hh:175

References kFileName.

◆ getID()

std::string & G4GMocrenIO::getID ( )

inline

Definition at line 261 of file G4GMocrenIO.hh.

261{return kId;}

G4GMocrenIO::kId

static std::string kId

Definition: G4GMocrenIO.hh:169

References kId.

◆ getModalityCenterPosition()

void G4GMocrenIO::getModalityCenterPosition ( float _center[3] )

Definition at line 3430 of file G4GMocrenIO.cc.

                                                            {
 
  if(isROIEmpty())
    for(int i = 0; i < 3; i++) _center[i] = 0;
  else 
    kModality.getCenterPosition(_center);
}

References GMocrenDataPrimitive< T >::getCenterPosition(), isROIEmpty(), and kModality.

◆ getModalityImage()

short * G4GMocrenIO::getModalityImage ( int _z )

Definition at line 3386 of file G4GMocrenIO.cc.

                                            {
  
  return kModality.getImage(_z);
}

References GMocrenDataPrimitive< T >::getImage(), and kModality.

◆ getModalityImageDensityMap()

std::vector< float > & G4GMocrenIO::getModalityImageDensityMap ( )

Definition at line 3398 of file G4GMocrenIO.cc.

                                                           {
  return kModalityImageDensityMap;
}

References kModalityImageDensityMap.

◆ getModalityImageMax()

short G4GMocrenIO::getModalityImageMax ( )

Definition at line 3413 of file G4GMocrenIO.cc.

                                       {
 
  short minmax[2];
  kModality.getMinMax(minmax);
  return minmax[1];
}

References GMocrenDataPrimitive< T >::getMinMax(), and kModality.

◆ getModalityImageMin()

short G4GMocrenIO::getModalityImageMin ( )

Definition at line 3419 of file G4GMocrenIO.cc.

                                       {
 
  short minmax[2];
  kModality.getMinMax(minmax);
  return minmax[0];
}

References GMocrenDataPrimitive< T >::getMinMax(), and kModality.

◆ getModalityImageMinMax()

void G4GMocrenIO::getModalityImageMinMax ( short _minmax[2] )

Definition at line 3407 of file G4GMocrenIO.cc.

                                                         {
 
  short minmax[2];
  kModality.getMinMax(minmax);
  for(int i = 0; i < 2; i++) _minmax[i] = minmax[i];
}  

References GMocrenDataPrimitive< T >::getMinMax(), and kModality.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ getModalityImageScale()

double G4GMocrenIO::getModalityImageScale ( )

Definition at line 3376 of file G4GMocrenIO.cc.

                                          {
 
  return kModality.getScale();
}

References GMocrenDataPrimitive< T >::getScale(), and kModality.

◆ getModalityImageSize()

void G4GMocrenIO::getModalityImageSize ( int _size[3] )

Definition at line 3362 of file G4GMocrenIO.cc.

                                                   {
 
  kModality.getSize(_size);
}

References GMocrenDataPrimitive< T >::getSize(), and kModality.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ getModalityImageUnit()

std::string G4GMocrenIO::getModalityImageUnit ( )

Definition at line 3438 of file G4GMocrenIO.cc.

                                            {
  return kModalityUnit;
}

References kModalityUnit.

◆ getModalityImageVoxelSpacing()

void G4GMocrenIO::getModalityImageVoxelSpacing ( float _size[3] )

◆ getNumberOfDetectors()

int G4GMocrenIO::getNumberOfDetectors ( )

Definition at line 3945 of file G4GMocrenIO.cc.

                                       {
  return (int)kDetectors.size();
}

References kDetectors.

◆ getNumberOfEvents()

int & G4GMocrenIO::getNumberOfEvents ( )

Definition at line 3136 of file G4GMocrenIO.cc.

                                     {
  return kNumberOfEvents;
}

References kNumberOfEvents.

◆ getNumDoseDist()

int G4GMocrenIO::getNumDoseDist ( )

Definition at line 3470 of file G4GMocrenIO.cc.

                                {
  return (int)kDose.size();
}

References kDose.

Referenced by calcPointers3(), calcPointers4(), clearDoseDistAll(), storeData3(), and storeData4().

◆ getNumROI()

int G4GMocrenIO::getNumROI ( )

Definition at line 3746 of file G4GMocrenIO.cc.

                           {
  return (int)kRoi.size();
}

References kRoi.

Referenced by clearROIAll().

◆ getNumTracks()

int G4GMocrenIO::getNumTracks ( )

Definition at line 3835 of file G4GMocrenIO.cc.

                               {
  return (int)kSteps.size();
}

References kSteps.

Referenced by calcPointers2(), and calcPointers3().

◆ getNumTracks4()

int G4GMocrenIO::getNumTracks4 ( )

Definition at line 3838 of file G4GMocrenIO.cc.

                                {
  return (int)kTracks.size();
}

References kTracks.

◆ getPointerToDoseDistData()

unsigned int G4GMocrenIO::getPointerToDoseDistData ( int _elem = 0 )

Definition at line 3157 of file G4GMocrenIO.cc.

                                                            {
  if(kPointerToDoseDistData.size() == 0 ||
     kPointerToDoseDistData.size() < (size_t)_elem)
    return 0;
  else
    return kPointerToDoseDistData[_elem];
}

References kPointerToDoseDistData.

◆ getPointerToModalityData()

unsigned int G4GMocrenIO::getPointerToModalityData ( )

Definition at line 3150 of file G4GMocrenIO.cc.

                                                   {
  return kPointerToModalityData;
}

References kPointerToModalityData.

◆ getPointerToROIData()

unsigned int G4GMocrenIO::getPointerToROIData ( )

Definition at line 3169 of file G4GMocrenIO.cc.

                                              {
  return kPointerToROIData;
}

References kPointerToROIData.

◆ getPointerToTrackData()

unsigned int G4GMocrenIO::getPointerToTrackData ( )

Definition at line 3176 of file G4GMocrenIO.cc.

                                                {
  return kPointerToTrackData;
}

References kPointerToTrackData.

◆ getROI()

short * G4GMocrenIO::getROI	(	int	_z,
		int	_num = `0`
	)

Definition at line 3767 of file G4GMocrenIO.cc.

                                            {
 
  if(isROIEmpty())
    return 0;
  else 
    return kRoi[_num].getImage(_z);
}

References isROIEmpty(), and kRoi.

◆ getROICenterPosition()

void G4GMocrenIO::getROICenterPosition	(	float	_center[3],
		int	_num = `0`
	)

Definition at line 3803 of file G4GMocrenIO.cc.

                                                                 {
 
  if(isROIEmpty())
    for(int i = 0; i < 3; i++) _center[i] = 0;
  else 
    kRoi[_num].getCenterPosition(_center);
}

References isROIEmpty(), and kRoi.

◆ getROIMinMax()

void G4GMocrenIO::getROIMinMax	(	short	_minmax[2],
		int	_num = `0`
	)

Definition at line 3791 of file G4GMocrenIO.cc.

                                                         {
 
  if(isROIEmpty())
    for(int i = 0; i < 2; i++) _minmax[i] = 0;
  else 
    kRoi[_num].getMinMax(_minmax);
}

References isROIEmpty(), and kRoi.

◆ getROIScale()

double G4GMocrenIO::getROIScale ( int _num = 0 )

Definition at line 3755 of file G4GMocrenIO.cc.

                                        {
 
  if(isROIEmpty())
    return 0.;
  else 
    return kRoi[_num].getScale();
}

References isROIEmpty(), and kRoi.

◆ getROISize()

void G4GMocrenIO::getROISize	(	int	_size[3],
		int	_num = `0`
	)

Definition at line 3779 of file G4GMocrenIO.cc.

                                                   {
 
  if(isROIEmpty())
    for(int i = 0; i < 3; i++) _size[i] = 0;
  else 
    return kRoi[_num].getSize(_size);
}

References isROIEmpty(), and kRoi.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ getShortDoseDist()

void G4GMocrenIO::getShortDoseDist	(	short *	_data,
		int	_z,
		int	_num = `0`
	)

Definition at line 3575 of file G4GMocrenIO.cc.

                                                                  {
 
  if(_data == NULL) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "In G4GMocrenIO::getShortDoseDist(), "
        << "first argument is NULL pointer. "
        << "The argument must be allocated array."
        << G4endl;
    G4Exception("G4GMocrenIO::getShortDoseDist()",
                "gMocren2002", FatalException,
                "Error.");
    return;
  }
 
  int size[3];
  kDose[_num].getSize(size);
  //short * shdata = new short[size[0]*size[1]];
  double * ddata = kDose[_num].getImage(_z);
  double scale = kDose[_num].getScale();
  for(int xy = 0; xy < size[0]*size[1]; xy++) {
    _data[xy] = (short)(ddata[xy]/scale+0.5); //there is never negative value
  }
}

References G4VisManager::errors, FatalException, G4cout, G4endl, G4Exception(), G4VisManager::GetVerbosity(), and kDose.

Referenced by storeData2(), storeData3(), and storeData4().

◆ getShortDoseDistMinMax()

void G4GMocrenIO::getShortDoseDistMinMax	(	short	_minmax[2],
		int	_num = `0`
	)

Definition at line 3598 of file G4GMocrenIO.cc.

                                                                   {
  double scale = kDose[_num].getScale();
  double minmax[2];
  kDose[_num].getMinMax(minmax);
  for(int i = 0; i < 2; i++)
    _minmax[i] = (short)(minmax[i]/scale+0.5);
}

References kDose.

Referenced by storeData2(), storeData3(), and storeData4().

◆ getTrack()

void G4GMocrenIO::getTrack	(	int	_num,
		std::vector< float * > &	_steps,
		std::vector< unsigned char * > &	_color
	)

Definition at line 3909 of file G4GMocrenIO.cc.

                                                      {
 
  if(_num > (int)kTracks.size()) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "ERROR in getTrack() : " << G4endl;
    G4Exception("G4GMocrenIO::getTrack()",
                "gMocren2003", FatalException,
                "Error.");
  }
  unsigned char * color = new unsigned char[3];
  kTracks[_num].getColor(color);
  _color.push_back(color);
 
  // steps
  int nsteps = kTracks[_num].getNumberOfSteps();
  for(int isteps = 0; isteps < nsteps; isteps++) {
    float * stepPoints = new float[6];
    kTracks[_num].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
              stepPoints[3], stepPoints[4], stepPoints[5],
              isteps);
    _steps.push_back(stepPoints);
  }
}

References G4VisManager::errors, FatalException, G4cout, G4endl, G4Exception(), G4VisManager::GetVerbosity(), and kTracks.

◆ getTrackColors()

std::vector< unsigned char * > & G4GMocrenIO::getTrackColors ( )

Definition at line 3856 of file G4GMocrenIO.cc.

                                                         {
  return kStepColors;
}

References kStepColors.

◆ getTracks()

std::vector< float * > & G4GMocrenIO::getTracks ( )

Definition at line 3847 of file G4GMocrenIO.cc.

                                            {
  return kSteps;
}

References kSteps.

◆ getVersion()

std::string & G4GMocrenIO::getVersion ( )

Definition at line 3120 of file G4GMocrenIO.cc.

3120{return kVersion;}

G4GMocrenIO::kVersion

static std::string kVersion

Definition: G4GMocrenIO.hh:172

References kVersion.

◆ getVoxelSpacing()

void G4GMocrenIO::getVoxelSpacing ( float _spacing[3] )

Definition at line 3131 of file G4GMocrenIO.cc.

                                                   {
  for(int i = 0; i < 3; i++) _spacing[i] = kVoxelSpacing[i];
}

References kVoxelSpacing.

◆ initialize()

void G4GMocrenIO::initialize ( )

Definition at line 412 of file G4GMocrenIO.cc.

                             {
 
  kId.clear();
  kVersion = "2.0.0";
  kNumberOfEvents = 0;
  kLittleEndianInput = true;
#if BYTE_ORDER == LITTLE_ENDIAN
  kLittleEndianOutput = true;
#else // Big endian
  kLittleEndianOutput = false;
#endif
  kComment.clear();
  kFileName = "dose.gdd";
  kPointerToModalityData = 0;
  kPointerToDoseDistData.clear();
  kPointerToROIData = 0;
  kPointerToTrackData = 0;
  // modality
  for(int i = 0; i < 3; i++) kVoxelSpacing[i] = 0.;
  kModality.clear();
  kModalityImageDensityMap.clear();
  kModalityUnit = "g/cm3       "; // 12 Bytes
  // dose
  kDose.clear();
  kDoseUnit = "keV         "; // 12 Bytes
  // ROI
  kRoi.clear();
  // track
  std::vector<float *>::iterator itr;
  for(itr = kSteps.begin(); itr != kSteps.end(); itr++) delete [] *itr;
  kSteps.clear();
  std::vector<unsigned char *>::iterator citr;
  for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++)
    delete [] *citr;
  kStepColors.clear();
  kTracksWillBeStored = true;
 
  // verbose
  kVerbose = 0;
}

References GMocrenDataPrimitive< T >::clear(), kComment, kDose, kDoseUnit, kFileName, kId, kLittleEndianInput, kLittleEndianOutput, kModality, kModalityImageDensityMap, kModalityUnit, kNumberOfEvents, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kStepColors, kSteps, kTracksWillBeStored, kVerbose, kVersion, and kVoxelSpacing.

◆ invertByteOrder()

template<typename T >

void G4GMocrenIO::invertByteOrder	(	char *	_val,
		T &	_rval
	)

protected

Definition at line 4027 of file G4GMocrenIO.cc.

                                                        {
 
  const int SIZE = sizeof(_rval);
  //char * cval = new char[SIZE];
  union {
    char cu[16];
    T tu;
  } uni;
  for(int i = 0; i < SIZE; i++) {
    uni.cu[i] = _val[SIZE-1-i];
    //cval[i] = _val[SIZE-i-1];
  }
  //_rval = *(T *)cval;
  _rval = uni.tu;
  //delete [] cval;
}

Referenced by storeData4().

◆ isDoseEmpty()

bool G4GMocrenIO::isDoseEmpty ( )

protected

Definition at line 3715 of file G4GMocrenIO.cc.

                              {
  if(kDose.empty()) {
    //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
    //  G4cout << "!!! dose distribution data is empty." << G4endl;
    return true;
  } else {
    return false;
  }
}

References kDose.

Referenced by clearDoseDistAll(), getDoseDist(), getDoseDistCenterPosition(), getDoseDistMinMax(), getDoseDistName(), getDoseDistScale(), getDoseDistSize(), storeData2(), storeData3(), and storeData4().

◆ isROIEmpty()

bool G4GMocrenIO::isROIEmpty ( )

protected

Definition at line 3821 of file G4GMocrenIO.cc.

                             {
  if(kRoi.empty()) {
    //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
    //  G4cout << "!!! ROI data is empty." << G4endl;
    return true;
  } else {
    return false;
  }
}

References kRoi.

Referenced by calcPointers2(), calcPointers3(), calcPointers4(), clearROIAll(), getModalityCenterPosition(), getROI(), getROICenterPosition(), getROIMinMax(), getROIScale(), getROISize(), storeData2(), storeData3(), and storeData4().

◆ mergeDoseDist()

bool G4GMocrenIO::mergeDoseDist ( std::vector< class GMocrenDataPrimitive< double > > & _dose )

Definition at line 3682 of file G4GMocrenIO.cc.

                                                                                      {
  if(kDose.size() != _dose.size()) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
      G4cout << "G4GMocrenIO::mergeDoseDist() : Error" << G4endl; 
      G4cout << "   Unable to merge the dose distributions,"<< G4endl;
      G4cout << "   because of different size of dose maps."<< G4endl;
    }
    return false;
  }
 
  int num = kDose.size();
  std::vector<class GMocrenDataPrimitive<double> >::iterator itr1 = kDose.begin();
  std::vector<class GMocrenDataPrimitive<double> >::iterator itr2 = _dose.begin();
  for(int i = 0; i < num; i++, itr1++, itr2++) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      if(kVerbose > 0)
    G4cout << "merged dose distribution [" << i << "]" << G4endl;
    *itr1 += *itr2;
  }
 
  return true;
}

References G4VisManager::errors, G4cout, G4endl, G4VisManager::GetVerbosity(), kDose, and kVerbose.

◆ mergeTracks()

void G4GMocrenIO::mergeTracks	(	std::vector< float * > &	_tracks,
		std::vector< unsigned char * > &	_colors
	)

Definition at line 3879 of file G4GMocrenIO.cc.

                                                      {
  std::vector<float *>::iterator titr;
  for(titr = _tracks.begin(); titr != _tracks.end(); titr++) {
    addTrack(*titr);
  }
 
  std::vector<unsigned char *>::iterator citr;
  for(citr = _colors.begin(); citr != _colors.end(); citr++) {
    addTrackColor(*citr);
  }
}

References addTrack(), and addTrackColor().

◆ newDoseDist()

void G4GMocrenIO::newDoseDist ( )

Definition at line 3466 of file G4GMocrenIO.cc.

                              {
  GMocrenDataPrimitive<double> doseData;
  kDose.push_back(doseData);
}

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd(), retrieveData2(), retrieveData3(), and retrieveData4().

◆ newROI()

void G4GMocrenIO::newROI ( )

Definition at line 3742 of file G4GMocrenIO.cc.

                         {
  GMocrenDataPrimitive<short>  roiData;
  kRoi.push_back(roiData);
}

References kRoi.

Referenced by retrieveData2(), retrieveData3(), and retrieveData4().

◆ notStoredTracks()

void G4GMocrenIO::notStoredTracks ( )

inline

Definition at line 437 of file G4GMocrenIO.hh.

437{kTracksWillBeStored = false;};

References kTracksWillBeStored.

◆ retrieveData() [1/2]

bool G4GMocrenIO::retrieveData ( )

Definition at line 1594 of file G4GMocrenIO.cc.

                               {
 
  // input file open
  std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
  if(!ifile) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "Cannot open file: " << kFileName
         << " in G4GMocrenIO::retrieveData()." << G4endl;
    return false;
  }
 
  // file identifier
  char verid[9];
  ifile.read((char *)verid, 8);
  // file version
  unsigned char ver;
  ifile.read((char *)&ver, 1);
  ifile.close();
 
  if(std::strncmp(verid, "gMocren", 7) == 0) {
    if(ver == 0x03) {
      G4cout << ">>>>>>>  retrieve data (ver.3) <<<<<<<" << G4endl;
      G4cout << "         " << kFileName << G4endl;
      retrieveData3();
    } else if (ver == 0x04) {
      G4cout << ">>>>>>>  retrieve data (ver.4) <<<<<<<" << G4endl;
      G4cout << "         " << kFileName << G4endl;
      retrieveData4();
    } else {
      if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
    G4cout << "Error -- invalid file version : " << (int)ver
          << G4endl;
    G4cout << "         " << kFileName << G4endl;
      }
      G4Exception("G4GMocrenIO::retrieveDadta()",
                  "gMocren2001", FatalException,
                  "Error.");
 
    }
  } else if(std::strncmp(verid, "GRAPE", 5) == 0) {
    G4cout << ">>>>>>>  retrieve data (ver.2) <<<<<<<" << G4endl;
    G4cout << "         " << kFileName << G4endl;
    retrieveData2();
  } else {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << kFileName << " was not gdd file." << G4endl;
    return false;
  }
 
  return true;
}

References G4VisManager::errors, FatalException, G4cout, G4endl, G4Exception(), G4VisManager::GetVerbosity(), kFileName, retrieveData2(), retrieveData3(), and retrieveData4().

Referenced by retrieveData(), retrieveData2(), retrieveData3(), and retrieveData4().

◆ retrieveData() [2/2]

bool G4GMocrenIO::retrieveData ( char * _filename )

Definition at line 1646 of file G4GMocrenIO.cc.

                                               {
  kFileName = _filename;
  return retrieveData();
}

References kFileName, and retrieveData().

◆ retrieveData2() [1/2]

bool G4GMocrenIO::retrieveData2 ( )

Definition at line 2623 of file G4GMocrenIO.cc.

                                {
 
  bool DEBUG = false;//
 
  // input file open
  std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
  if(!ifile) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "Cannot open file: " << kFileName
        << " in G4GMocrenIO::retrieveData2()." << G4endl;
    return false;
  }
 
  // data buffer
  char ctmp[12];
 
  // file identifier
  char verid[9];
  ifile.read((char *)verid, 8);
 
  // file version
  unsigned char ver;
  ifile.read((char *)&ver, 1);
  std::stringstream ss;
  ss << (int)ver;
  kVersion = ss.str();
  if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
 
  // id of version 1
  char idtmp[IDLENGTH];
  ifile.read((char *)idtmp, IDLENGTH);
  kId = idtmp;
  // version of version 1
  char vertmp[VERLENGTH];
  ifile.read((char *)vertmp, VERLENGTH);
 
  // endian
  ifile.read((char *)&kLittleEndianInput, sizeof(char));
  if(DEBUG || kVerbose > 0) {
    G4cout << "Endian : ";
    if(kLittleEndianInput == 1) 
      G4cout << " little" << G4endl;
    else {
      G4cout << " big" << G4endl;
    }
  }
 
  // voxel spacings for all images
  ifile.read((char *)ctmp, 12);
  convertEndian(ctmp, kVoxelSpacing[0]);
  convertEndian(ctmp+4, kVoxelSpacing[1]);
  convertEndian(ctmp+8, kVoxelSpacing[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
 
  // offset from file starting point to the modality image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToModalityData);
 
  // offset from file starting point to the dose image data
  unsigned int ptddd;
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, ptddd);
  kPointerToDoseDistData.push_back(ptddd);
 
  // offset from file starting point to the ROI image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToROIData);
 
  // offset from file starting point to the track data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToTrackData);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", "
          << kPointerToDoseDistData[0] << ", "
          << kPointerToROIData << ", "
          << kPointerToTrackData << G4endl;
  }
 
  if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
     kPointerToROIData == 0 && kPointerToTrackData == 0) {
    if(DEBUG || kVerbose > 0) {
      G4cout << "No data." << G4endl;
    }
    return false;
  }
 
  // event number
  /* ver 1
     ifile.read(ctmp, sizeof(int));
     convertEndian(ctmp, numberOfEvents);
  */
 
  int size[3];
  float scale;
  double dscale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
 
  //----- Modality image -----//
  // modality image size
  ifile.read(ctmp, 3*sizeof(int));
  convertEndian(ctmp, size[0]);
  convertEndian(ctmp+sizeof(int), size[1]);
  convertEndian(ctmp+2*sizeof(int), size[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
  kModality.setSize(size);
 
  // modality image voxel spacing
  /*
    ifile.read(ctmp, 3*sizeof(float));
    convertEndian(ctmp, modalityImageVoxelSpacing[0]);
    convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
    convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
  */
 
  if(kPointerToModalityData != 0) {
 
    // modality density max. & min.
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
    kModality.setMinMax(minmax);
 
    // modality density scale
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, scale);
    kModality.setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Modality image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // modality density
    int psize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
    char * cimage = new char[psize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)cimage, psize*sizeof(short));
      short * mimage = new short[psize];
      for(int j = 0; j < psize; j++) {
    convertEndian(cimage+j*sizeof(short), mimage[j]);
      }
      kModality.addImage(mimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
    }
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
    delete [] cimage;
 
    // modality desity map for CT value
    size_t msize = minmax[1]-minmax[0]+1;
    if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
    char * pdmap = new char[msize*sizeof(float)];
    ifile.read((char *)pdmap, msize*sizeof(float));
    float ftmp;
    for(int i = 0; i < (int)msize; i++) {
      convertEndian(pdmap+i*sizeof(float), ftmp);
      kModalityImageDensityMap.push_back(ftmp); 
    }
    delete [] pdmap;
    if(DEBUG || kVerbose > 0) {
      G4cout << "density map : " << std::ends;
      for(int i = 0; i < 10; i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
      for(int i = 0; i < 10; i++) G4cout << "..";
      G4cout << G4endl;
      for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
    }
 
  }
 
 
  //----- dose distribution image -----//
  if(kPointerToDoseDistData[0] != 0) {
 
    newDoseDist();
 
    // dose distrbution image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
    kDose[0].setSize(size);
 
    // dose distribution max. & min. 
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
    // dose distribution scaling 
    ifile.read((char *)ctmp, sizeof(float));
    convertEndian(ctmp, scale);
    kDose[0].setScale(dscale = scale);
 
    double dminmax[2];
    for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
    kDose[0].setMinMax(dminmax);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image min., max., scale : "
        << dminmax[0] << ", "
        << dminmax[1] << ", "
        << scale << G4endl;
    }
 
    // dose distribution image
    int dsize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
    char * di = new char[dsize*sizeof(short)];
    short * shimage = new short[dsize];
    for(int z = 0; z < size[2]; z++) {
      ifile.read((char *)di, dsize*sizeof(short));
      double * dimage = new double[dsize];
      for(int xy = 0; xy < dsize; xy++) {
    convertEndian(di+xy*sizeof(short), shimage[xy]);
    dimage[xy] = shimage[xy]*dscale;
      }
      kDose[0].addImage(dimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
 
      if(DEBUG || kVerbose > 0) {
    for(int j = 0; j < dsize; j++) {
      if(dimage[j] < 0)
        G4cout << "[" << j << "," << z << "]"
              << dimage[j] << ", ";
    }
      }
    }
    delete [] shimage;
    delete [] di;
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
    /* ver 1
       float doseDist;
       int dosePid;
       double * doseData = new double[numDoseImageVoxels];
       for(int i = 0; i < numDose; i++) {
       ifile.read(ctmp, sizeof(int));
       convertEndian(ctmp, dosePid);
       for(int j = 0; j < numDoseImageVoxels; j++) {
       ifile.read(ctmp, sizeof(float));
       convertEndian(ctmp, doseDist);
       doseData[j] = doseDist;
       }
       setDose(dosePid, doseData);
       }
       delete [] doseData;
       if(totalDose == NULL) totalDose = new double[numDoseImageVoxels];
       for(int i = 0; i < numDoseImageVoxels; i++) {
       ifile.read(ctmp, sizeof(float));
       convertEndian(ctmp, doseDist);
       totalDose[i] = doseDist;
       }
    */
 
    /* ver 1
    // relative location between the two images
    ifile.read(ctmp, 3*sizeof(float));
    convertEndian(ctmp, relativeLocation[0]);
    convertEndian(ctmp+sizeof(float), relativeLocation[1]);
    convertEndian(ctmp+2*sizeof(float), relativeLocation[2]);
    */
 
    // relative location of the dose distribution image for 
    // the modality image
    //ofile.write((char *)relativeLocation, 3*sizeof(float));
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+sizeof(int), iCenter[1]);
    convertEndian(ctmp+2*sizeof(int), iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
    kDose[0].setCenterPosition(fCenter);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
 
  }
 
  //----- ROI image -----//
  if(kPointerToROIData != 0) {
 
    newROI();
 
    // ROI image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    kRoi[0].setSize(size);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+sizeof(short), minmax[1]);
    kRoi[0].setMinMax(minmax);
 
    // ROI distribution scaling 
    ifile.read((char *)ctmp, sizeof(float));
    convertEndian(ctmp, scale);
    kRoi[0].setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    char * ri = new char[rsize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)ri, rsize*sizeof(short));
      short * rimage = new short[rsize];
      for(int j = 0; j < rsize; j++) {
    convertEndian(ri+j*sizeof(short), rimage[j]);
      }
      kRoi[0].addImage(rimage);
 
    }
    delete [] ri;
 
    // ROI relative location
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+sizeof(int), iCenter[1]);
    convertEndian(ctmp+2*sizeof(int), iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
    kRoi[0].setCenterPosition(fCenter);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
  }
 
  //----- track information -----//
  if(kPointerToTrackData != 0) {
 
    // track
    ifile.read((char *)ctmp, sizeof(int));
    int ntrk;
    convertEndian(ctmp, ntrk);
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of tracks: " << ntrk << G4endl;
    }
 
    //v4
    unsigned char trkcolorv4[3] = {255, 0, 0};
 
    for(int i = 0; i < ntrk; i++) {
      float * tp = new float[6];
      // v4
      std::vector<float *> trkv4;
 
      ifile.read((char *)ctmp, sizeof(float)*3);
      if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
      for(int j = 0; j < 3; j++) {
    convertEndian(ctmp+j*sizeof(float), tp[j]);
    if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
      }
 
      ifile.read((char *)ctmp, sizeof(float)*3);
      for(int j = 0; j < 3; j++) {
    convertEndian(ctmp+j*sizeof(float), tp[j+3]);
    if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
      }
 
      kSteps.push_back(tp);
      // v4
      trkv4.push_back(tp);
      addTrack(trkv4, trkcolorv4);
      
      if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
    }
 
  }
 
  /* ver 1
  // track
  int ntracks;
  ifile.read(ctmp, sizeof(int));
  convertEndian(ctmp, ntracks);
  // track displacement
  ifile.read(ctmp, 3*sizeof(float));
  convertEndian(ctmp, trackDisplacement[0]);
  convertEndian(ctmp+sizeof(float), trackDisplacement[2]); // exchanged with [1]
  convertEndian(ctmp+2*sizeof(float), trackDisplacement[1]);
  //
  //for(int i = 0; i < ntracks && i < 100; i++) {
  for(int i = 0; i < ntracks; i++) {
  DicomDoseTrack trk;
  short trackid, parentid, pid;
  int npoints;
  ifile.read(ctmp, sizeof(short));
  convertEndian(ctmp, trackid);
  trk.setID(trackid);
  ifile.read(ctmp, sizeof(short));
  convertEndian(ctmp, parentid);
  trk.setParentID(parentid);
  ifile.read(ctmp, sizeof(short));
  convertEndian(ctmp, pid);
  trk.setPID(pid);
  ifile.read(ctmp, sizeof(int));
  convertEndian(ctmp, npoints);
  for(int i = 0; i < npoints; i++) {
  ifile.read(ctmp, 3*sizeof(float));
  // storing only start and end points
  //if(i == 0 || i == npoints - 1) {
  float * point = new float[3];
  convertEndian(ctmp, point[0]);
  convertEndian(ctmp+sizeof(float), point[1]);
  convertEndian(ctmp+2*sizeof(float), point[2]);
  trk.addPoint(point);
  //}
  }
  track.push_back(trk);
  }
  */
 
  ifile.close();
 
  return true;
}

References GMocrenDataPrimitive< T >::addImage(), addTrack(), convertEndian(), G4FFGEnumerations::DEBUG, G4VisManager::errors, G4cout, G4endl, G4VisManager::GetVerbosity(), IDLENGTH, kDose, kFileName, kId, kLittleEndianInput, kModality, kModalityImageDensityMap, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kSteps, kVerbose, kVersion, kVoxelSpacing, newDoseDist(), newROI(), GMocrenDataPrimitive< T >::setMinMax(), GMocrenDataPrimitive< T >::setScale(), GMocrenDataPrimitive< T >::setSize(), G4InuclParticleNames::tp, and VERLENGTH.

Referenced by retrieveData().

◆ retrieveData2() [2/2]

bool G4GMocrenIO::retrieveData2 ( char * _filename )

Definition at line 3088 of file G4GMocrenIO.cc.

                                                {
  kFileName = _filename;
  return retrieveData();
}

References kFileName, and retrieveData().

◆ retrieveData3() [1/2]

bool G4GMocrenIO::retrieveData3 ( )

Definition at line 2185 of file G4GMocrenIO.cc.

                                {
 
  bool DEBUG = false;//
 
  // input file open
  std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
  if(!ifile) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "Cannot open file: " << kFileName
        << " in G4GMocrenIO::retrieveData3()." << G4endl;
    return false;
  }
 
  // data buffer
  char ctmp[12];
 
  // file identifier
  char verid[9];
  ifile.read((char *)verid, 8);
 
  // file version
  unsigned char ver;
  ifile.read((char *)&ver, 1);
  std::stringstream ss;
  ss << (int)ver;
  kVersion = ss.str();
  if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
 
  // endian
  ifile.read((char *)&kLittleEndianInput, sizeof(char));
  if(DEBUG || kVerbose > 0) {
    G4cout << "Endian : ";
    if(kLittleEndianInput == 1) 
      G4cout << " little" << G4endl;
    else {
      G4cout << " big" << G4endl;
    }
  }
 
  // comment length (fixed size)
  int clength;
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, clength);
  // comment
  char cmt[1025];
  ifile.read((char *)cmt, clength);
  std::string scmt = cmt;
  setComment(scmt);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Data comment : "
          << kComment << G4endl;
  }
 
  // voxel spacings for all images
  ifile.read((char *)ctmp, 12);
  convertEndian(ctmp, kVoxelSpacing[0]);
  convertEndian(ctmp+4, kVoxelSpacing[1]);
  convertEndian(ctmp+8, kVoxelSpacing[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
 
  // offset from file starting point to the modality image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToModalityData);
 
  // # of dose distributions
  ifile.read((char *)ctmp, 4);
  int nDoseDist;
  convertEndian(ctmp, nDoseDist);
  
  // offset from file starting point to the dose image data
  for(int i = 0; i < nDoseDist; i++) {
    ifile.read((char *)ctmp, 4);
    unsigned int dptr;
    convertEndian(ctmp, dptr);
    addPointerToDoseDistData(dptr);
  }
 
  // offset from file starting point to the ROI image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToROIData);
 
  // offset from file starting point to the track data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToTrackData);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", ";
    for(int i = 0; i < nDoseDist; i++)
      G4cout << kPointerToDoseDistData[0] << ", ";
    G4cout << kPointerToROIData << ", "
          << kPointerToTrackData << G4endl;
  }
 
  if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
     kPointerToROIData == 0 && kPointerToTrackData == 0) {
    if(DEBUG || kVerbose > 0) {
      G4cout << "No data." << G4endl;
    }
    return false;
  }
 
  // event number
  /* ver 1
     ifile.read(ctmp, sizeof(int));
     convertEndian(ctmp, numberOfEvents);
  */
 
  int size[3];
  float scale;
  double dscale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
 
  //----- Modality image -----//
  // modality image size
  ifile.read(ctmp, 3*sizeof(int));
  convertEndian(ctmp, size[0]);
  convertEndian(ctmp+sizeof(int), size[1]);
  convertEndian(ctmp+2*sizeof(int), size[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
  kModality.setSize(size);
 
  // modality image voxel spacing
  /*
    ifile.read(ctmp, 3*sizeof(float));
    convertEndian(ctmp, modalityImageVoxelSpacing[0]);
    convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
    convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
  */
 
  if(kPointerToModalityData != 0) {
 
    // modality density max. & min.
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
    kModality.setMinMax(minmax);
 
    // modality image unit
    char munit[13];
    ifile.read((char *)munit, 12);
    std::string smunit = munit;
    setModalityImageUnit(smunit);
 
    // modality density scale
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, scale);
    kModality.setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Modality image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // modality density
    int psize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
    char * cimage = new char[psize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)cimage, psize*sizeof(short));
      short * mimage = new short[psize];
      for(int j = 0; j < psize; j++) {
    convertEndian(cimage+j*sizeof(short), mimage[j]);
      }
      kModality.addImage(mimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
    }
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
    delete [] cimage;
 
    // modality desity map for CT value
    size_t msize = minmax[1]-minmax[0]+1;
    if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
    char * pdmap = new char[msize*sizeof(float)];
    ifile.read((char *)pdmap, msize*sizeof(float));
    float ftmp;
    for(int i = 0; i < (int)msize; i++) {
      convertEndian(pdmap+i*sizeof(float), ftmp);
      kModalityImageDensityMap.push_back(ftmp); 
    }
    delete [] pdmap;
    if(DEBUG || kVerbose > 0) {
      G4cout << "density map : " << std::ends;
      for(int i = 0; i < 10; i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
      for(int i = 0; i < 10; i++) G4cout << "..";
      G4cout << G4endl;
      for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
    }
 
  }
 
 
  //----- dose distribution image -----//
  for(int ndose = 0; ndose < nDoseDist; ndose++) {
 
    newDoseDist();
 
    // dose distrbution image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
    kDose[ndose].setSize(size);
 
    // dose distribution max. & min. 
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
 
    // dose distribution unit
    char dunit[13];
    ifile.read((char *)dunit, 12);
    std::string sdunit = dunit;
    setDoseDistUnit(sdunit, ndose);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
    }
 
    // dose distribution scaling 
    ifile.read((char *)ctmp, 4); // sizeof(float)
    convertEndian(ctmp, scale);
    kDose[ndose].setScale(dscale = scale);
 
    double dminmax[2];
    for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
    kDose[ndose].setMinMax(dminmax);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image min., max., scale : "
        << dminmax[0] << ", "
        << dminmax[1] << ", "
        << scale << G4endl;
    }
 
    // dose distribution image
    int dsize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
    char * di = new char[dsize*sizeof(short)];
    short * shimage = new short[dsize];
    for(int z = 0; z < size[2]; z++) {
      ifile.read((char *)di, dsize*sizeof(short));
      double * dimage = new double[dsize];
      for(int xy = 0; xy < dsize; xy++) {
    convertEndian(di+xy*sizeof(short), shimage[xy]);
    dimage[xy] = shimage[xy]*dscale;
      }
      kDose[ndose].addImage(dimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
 
      if(DEBUG || kVerbose > 0) {
    for(int j = 0; j < dsize; j++) {
      if(dimage[j] < 0)
        G4cout << "[" << j << "," << z << "]"
              << dimage[j] << ", ";
    }
      }
    }
    delete [] shimage;
    delete [] di;
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
    ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+4, iCenter[1]);
    convertEndian(ctmp+8, iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
    kDose[ndose].setCenterPosition(fCenter);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
 
  }
 
  //----- ROI image -----//
  if(kPointerToROIData != 0) {
 
    newROI();
 
    // ROI image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    kRoi[0].setSize(size);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+sizeof(short), minmax[1]);
    kRoi[0].setMinMax(minmax);
 
    // ROI distribution scaling 
    ifile.read((char *)ctmp, sizeof(float));
    convertEndian(ctmp, scale);
    kRoi[0].setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    char * ri = new char[rsize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)ri, rsize*sizeof(short));
      short * rimage = new short[rsize];
      for(int j = 0; j < rsize; j++) {
    convertEndian(ri+j*sizeof(short), rimage[j]);
      }
      kRoi[0].addImage(rimage);
 
    }
    delete [] ri;
 
    // ROI relative location
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+sizeof(int), iCenter[1]);
    convertEndian(ctmp+2*sizeof(int), iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
    kRoi[0].setCenterPosition(fCenter);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
  }
 
  //----- track information -----//
  if(kPointerToTrackData != 0) {
 
    // track
    ifile.read((char *)ctmp, sizeof(int));
    int ntrk;
    convertEndian(ctmp, ntrk);
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of tracks: " << ntrk << G4endl;
    }
 
    // v4
    std::vector<float *> trkv4;
 
    // track position
    for(int i = 0; i < ntrk; i++) {
      float * tp = new float[6];
 
      ifile.read((char *)ctmp, sizeof(float)*3);
      if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
      for(int j = 0; j < 3; j++) {
    convertEndian(ctmp+j*sizeof(float), tp[j]);
    if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
      }
 
      ifile.read((char *)ctmp, sizeof(float)*3);
      for(int j = 0; j < 3; j++) {
    convertEndian(ctmp+j*sizeof(float), tp[j+3]);
    if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
      }
      addTrack(tp);
      if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
 
      // v4
      trkv4.push_back(tp);
    }
 
    //v4
    unsigned char trkcolorv4[3];
 
    // track color
    for(int i = 0; i < ntrk; i++) {
      unsigned char * rgb = new unsigned char[3];
      ifile.read((char *)rgb, 3);
      addTrackColor(rgb);
 
      // v4
      for(int j = 0; j < 3; j++) trkcolorv4[j] = rgb[j];
      std::vector<float *> trk;
      trk.push_back(trkv4[i]);
      addTrack(trk, trkcolorv4);
 
    }
 
  }
 
  ifile.close();
 
  return true;
}

References GMocrenDataPrimitive< T >::addImage(), addPointerToDoseDistData(), addTrack(), addTrackColor(), convertEndian(), G4FFGEnumerations::DEBUG, G4VisManager::errors, G4cout, G4endl, G4VisManager::GetVerbosity(), kComment, kDose, kDoseUnit, kFileName, kLittleEndianInput, kModality, kModalityImageDensityMap, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kVerbose, kVersion, kVoxelSpacing, newDoseDist(), newROI(), setComment(), setDoseDistUnit(), GMocrenDataPrimitive< T >::setMinMax(), setModalityImageUnit(), GMocrenDataPrimitive< T >::setScale(), GMocrenDataPrimitive< T >::setSize(), and G4InuclParticleNames::tp.

Referenced by retrieveData().

◆ retrieveData3() [2/2]

bool G4GMocrenIO::retrieveData3 ( char * _filename )

Definition at line 2617 of file G4GMocrenIO.cc.

                                                {
  kFileName = _filename;
  return retrieveData();
}

References kFileName, and retrieveData().

◆ retrieveData4() [1/2]

bool G4GMocrenIO::retrieveData4 ( )

Definition at line 1652 of file G4GMocrenIO.cc.

                                {
 
  bool DEBUG = false;//
 
  // input file open
  std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
  if(!ifile) {
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "Cannot open file: " << kFileName
        << " in G4GMocrenIO::retrieveData3()." << G4endl;
    return false;
  }
 
  // data buffer
  char ctmp[24];
 
  // file identifier
  char verid[9];
  ifile.read((char *)verid, 8);
 
  // file version
  unsigned char ver;
  ifile.read((char *)&ver, 1);
  std::stringstream ss;
  ss << (int)ver;
  kVersion = ss.str();
  if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
 
  // endian
  ifile.read((char *)&kLittleEndianInput, sizeof(char));
  if(DEBUG || kVerbose > 0) {
    G4cout << "Endian : ";
    if(kLittleEndianInput == 1) 
      G4cout << " little" << G4endl;
    else {
      G4cout << " big" << G4endl;
    }
  }
 
  // comment length (fixed size)
  int clength;
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, clength);
  // comment
  char cmt[1025];
  ifile.read((char *)cmt, clength);
  std::string scmt = cmt;
  scmt += '\0';
  setComment(scmt);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Data comment : "
          << kComment << G4endl;
  }
 
  // voxel spacings for all images
  ifile.read((char *)ctmp, 12);
  convertEndian(ctmp, kVoxelSpacing[0]);
  convertEndian(ctmp+4, kVoxelSpacing[1]);
  convertEndian(ctmp+8, kVoxelSpacing[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
 
  // offset from file starting point to the modality image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToModalityData);
 
  // # of dose distributions
  ifile.read((char *)ctmp, 4);
  int nDoseDist;
  convertEndian(ctmp, nDoseDist);
  
  // offset from file starting point to the dose image data
  for(int i = 0; i < nDoseDist; i++) {
    ifile.read((char *)ctmp, 4);
    unsigned int dptr;
    convertEndian(ctmp, dptr);
    addPointerToDoseDistData(dptr);
  }
 
  // offset from file starting point to the ROI image data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToROIData);
 
  // offset from file starting point to the track data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToTrackData);
 
  // offset from file starting point to the detector data
  ifile.read((char *)ctmp, 4);
  convertEndian(ctmp, kPointerToDetectorData);
 
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", ";
    for(int i = 0; i < nDoseDist; i++)
      G4cout << kPointerToDoseDistData[i] << ", ";
    G4cout << kPointerToROIData << ", "
          << kPointerToTrackData << ", "
          << kPointerToDetectorData
          << G4endl;
  }
 
 
 
  if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
     kPointerToROIData == 0 && kPointerToTrackData == 0) {
    if(DEBUG || kVerbose > 0) {
      G4cout << "No data." << G4endl;
    }
    return false;
  }
 
  // event number
  /* ver 1
     ifile.read(ctmp, sizeof(int));
     convertEndian(ctmp, numberOfEvents);
  */
 
  int size[3];
  float scale;
  double dscale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
 
  //----- Modality image -----//
  // modality image size
  ifile.read(ctmp, 3*sizeof(int));
  convertEndian(ctmp, size[0]);
  convertEndian(ctmp+sizeof(int), size[1]);
  convertEndian(ctmp+2*sizeof(int), size[2]);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
  kModality.setSize(size);
 
  // modality image voxel spacing
  /*
    ifile.read(ctmp, 3*sizeof(float));
    convertEndian(ctmp, modalityImageVoxelSpacing[0]);
    convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
    convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
  */
 
  if(kPointerToModalityData != 0) {
 
    // modality density max. & min.
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
    kModality.setMinMax(minmax);
 
    // modality image unit
    char munit[13];
    munit[12] = '\0';
    ifile.read((char *)munit, 12);
    std::string smunit = munit;
    setModalityImageUnit(smunit);
 
    // modality density scale
    ifile.read((char *)ctmp, 4);
    convertEndian(ctmp, scale);
    kModality.setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Modality image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // modality density
    int psize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
    char * cimage = new char[psize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)cimage, psize*sizeof(short));
      short * mimage = new short[psize];
      for(int j = 0; j < psize; j++) {
    convertEndian(cimage+j*sizeof(short), mimage[j]);
      }
      kModality.addImage(mimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
    }
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
    delete [] cimage;
 
    // modality desity map for CT value
    size_t msize = minmax[1]-minmax[0]+1;
    if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
    char * pdmap = new char[msize*sizeof(float)];
    ifile.read((char *)pdmap, msize*sizeof(float));
    float ftmp;
    for(int i = 0; i < (int)msize; i++) {
      convertEndian(pdmap+i*sizeof(float), ftmp);
      kModalityImageDensityMap.push_back(ftmp); 
    }
    delete [] pdmap;
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "density map : " << std::ends;
      for(int i = 0; i < 10; i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
      for(int i = 0; i < 10; i++) G4cout << "..";
      G4cout << G4endl;
      for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
    G4cout <<kModalityImageDensityMap[i] << ", ";
      G4cout << G4endl;
    }
 
  }
 
 
  //----- dose distribution image -----//
  for(int ndose = 0; ndose < nDoseDist; ndose++) {
 
    newDoseDist();
 
    // dose distrbution image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
    kDose[ndose].setSize(size);
 
    // dose distribution max. & min. 
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+2, minmax[1]);
 
    // dose distribution unit
    char dunit[13];
    dunit[12] = '\0';
    ifile.read((char *)dunit, 12);
    std::string sdunit = dunit;
    setDoseDistUnit(sdunit, ndose);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
    }
 
    // dose distribution scaling 
    ifile.read((char *)ctmp, 4); // sizeof(float)
    convertEndian(ctmp, scale);
    kDose[ndose].setScale(dscale = scale);
 
    double dminmax[2];
    for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
    kDose[ndose].setMinMax(dminmax);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image min., max., scale : "
        << dminmax[0] << ", "
        << dminmax[1] << ", "
        << scale << G4endl;
    }
 
    // dose distribution image
    int dsize = size[0]*size[1];
    if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
    char * di = new char[dsize*sizeof(short)];
    short * shimage = new short[dsize];
    for(int z = 0; z < size[2]; z++) {
      ifile.read((char *)di, dsize*sizeof(short));
      double * dimage = new double[dsize];
      for(int xy = 0; xy < dsize; xy++) {
    convertEndian(di+xy*sizeof(short), shimage[xy]);
    dimage[xy] = shimage[xy]*dscale;
      }
      kDose[ndose].addImage(dimage);
 
      if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
 
      if(DEBUG || kVerbose > 0) {
    for(int j = 0; j < dsize; j++) {
      if(dimage[j] < 0)
        G4cout << "[" << j << "," << z << "]"
              << dimage[j] << ", ";
    }
      }
    }
    delete [] shimage;
    delete [] di;
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
    ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+4, iCenter[1]);
    convertEndian(ctmp+8, iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
    kDose[ndose].setCenterPosition(fCenter);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
 
    // dose distribution name
    char cname[81];
    ifile.read((char *)cname, 80);
    std::string dosename = cname;
    setDoseDistName(dosename, ndose);
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. name : " << dosename << G4endl;
    }
 
  }
 
  //----- ROI image -----//
  if(kPointerToROIData != 0) {
 
    newROI();
 
    // ROI image size
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, size[0]);
    convertEndian(ctmp+sizeof(int), size[1]);
    convertEndian(ctmp+2*sizeof(int), size[2]);
    kRoi[0].setSize(size);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    ifile.read((char *)ctmp, sizeof(short)*2);
    convertEndian(ctmp, minmax[0]);
    convertEndian(ctmp+sizeof(short), minmax[1]);
    kRoi[0].setMinMax(minmax);
 
    // ROI distribution scaling 
    ifile.read((char *)ctmp, sizeof(float));
    convertEndian(ctmp, scale);
    kRoi[0].setScale(dscale = scale);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    char * ri = new char[rsize*sizeof(short)];
    for(int i = 0; i < size[2]; i++) {
      ifile.read((char *)ri, rsize*sizeof(short));
      short * rimage = new short[rsize];
      for(int j = 0; j < rsize; j++) {
    convertEndian(ri+j*sizeof(short), rimage[j]);
      }
      kRoi[0].addImage(rimage);
 
    }
    delete [] ri;
 
    // ROI relative location
    ifile.read((char *)ctmp, 3*sizeof(int));
    convertEndian(ctmp, iCenter[0]);
    convertEndian(ctmp+sizeof(int), iCenter[1]);
    convertEndian(ctmp+2*sizeof(int), iCenter[2]);
    for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
    kRoi[0].setCenterPosition(fCenter);
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << fCenter[0] << ", "
        << fCenter[1] << ", "
        << fCenter[2] << ")" << G4endl;
    }
 
  }
 
  //----- track information -----//
  if(kPointerToTrackData != 0) {
 
    // track
    ifile.read((char *)ctmp, sizeof(int));
    int ntrk;
    convertEndian(ctmp, ntrk);
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of tracks: " << ntrk << G4endl;
    }
 
    // track position
    unsigned char rgb[3];
    for(int i = 0; i < ntrk; i++) {
 
 
      // # of steps in a track
      ifile.read((char *)ctmp, sizeof(int));
      int nsteps;
      convertEndian(ctmp, nsteps);
      
      // track color
      ifile.read((char *)rgb, 3);
 
      std::vector<float *> steps;
      // steps
      for(int j = 0; j < nsteps; j++) {
 
    float * steppoint = new float[6];
    ifile.read((char *)ctmp, sizeof(float)*6);
 
    for(int k = 0; k < 6; k++) {
      convertEndian(ctmp+k*sizeof(float), steppoint[k]);
    }
    
    steps.push_back(steppoint);
      }
 
      // add a track to the track container
      addTrack(steps, rgb);
 
      if(DEBUG || kVerbose > 0) {
    if(i < 5) {
      G4cout << i << ": " ;
      for(int j = 0; j < 3; j++) G4cout << steps[0][j] << " ";
      int nstp = steps.size();
      G4cout << "<-> ";
      for(int j = 3; j < 6; j++) G4cout << steps[nstp-1][j] << " ";
      G4cout << "    rgb( ";
      for(int j = 0; j < 3; j++) G4cout << (int)rgb[j] << " ";
      G4cout << ")" << G4endl;
    }
      }
    }
 
 
  }
 
 
  //----- detector information -----//
  if(kPointerToDetectorData != 0) {
 
    // number of detectors
    ifile.read((char *)ctmp, sizeof(int));
    int ndet;
    convertEndian(ctmp, ndet);
 
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of detectors : "
        << ndet << G4endl;
    }
 
    for(int nd = 0; nd < ndet; nd++) {
 
      // # of edges of a detector
      ifile.read((char *)ctmp, sizeof(int));
      int nedges;
      convertEndian(ctmp, nedges);
      if(DEBUG || kVerbose > 0) {
    G4cout << "# of edges in a detector : " << nedges << G4endl;
      }
 
      // edges
      std::vector<float *> detector;
      char cftmp[24];
      for(int ne = 0; ne < nedges; ne++) {
      
    ifile.read((char *)cftmp, sizeof(float)*6);
    float * edgePoints = new float[6];
    for(int j = 0; j < 6; j++) convertEndian(&cftmp[sizeof(float)*j], edgePoints[j]);
    detector.push_back(edgePoints);
 
      }
 
      if(DEBUG || kVerbose > 0) {
    G4cout << " first edge : (" << detector[0][0] << ", "
          << detector[0][1] << ", "
          << detector[0][2] << ") - ("
          << detector[0][3] << ", "
          << detector[0][4] << ", "
          << detector[0][5] << ")" << G4endl;
      }
 
      // detector color
      unsigned char dcolor[3];
      ifile.read((char *)dcolor, 3);
      if(DEBUG || kVerbose > 0) {
    G4cout << " detector color : rgb("
          << (int)dcolor[0] << ", "
          << (int)dcolor[1] << ", "
          << (int)dcolor[2] << G4endl;
      }
 
 
      // detector name
      char cname[80];
      ifile.read((char *)cname, 80);
      std::string dname = cname;
      if(DEBUG || kVerbose > 0) {
    G4cout << " detector name : " << dname << G4endl;
      }
 
 
      addDetector(dname, detector, dcolor);
 
    }
  }
 
 
  ifile.close();
 
  return true;
}

References addDetector(), GMocrenDataPrimitive< T >::addImage(), addPointerToDoseDistData(), addTrack(), convertEndian(), G4FFGEnumerations::DEBUG, G4VisManager::errors, G4cout, G4endl, G4VisManager::GetVerbosity(), kComment, kDose, kDoseUnit, kFileName, kLittleEndianInput, kModality, kModalityImageDensityMap, kPointerToDetectorData, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kVerbose, kVersion, kVoxelSpacing, newDoseDist(), newROI(), setComment(), setDoseDistName(), setDoseDistUnit(), GMocrenDataPrimitive< T >::setMinMax(), setModalityImageUnit(), GMocrenDataPrimitive< T >::setScale(), and GMocrenDataPrimitive< T >::setSize().

Referenced by retrieveData().

◆ retrieveData4() [2/2]

bool G4GMocrenIO::retrieveData4 ( char * _filename )

Definition at line 2179 of file G4GMocrenIO.cc.

                                                {
  kFileName = _filename;
  return retrieveData();
}

References kFileName, and retrieveData().

◆ setComment()

void G4GMocrenIO::setComment ( std::string & _comment )

inline

Definition at line 275 of file G4GMocrenIO.hh.

275{kComment = _comment;}

References kComment.

Referenced by retrieveData3(), and retrieveData4().

◆ setDoseDist()

void G4GMocrenIO::setDoseDist	(	double *	_image,
		int	_num = `0`
	)

Definition at line 3606 of file G4GMocrenIO.cc.

                                                       {
 
  kDose[_num].addImage(_image);
}

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setDoseDistCenterPosition()

void G4GMocrenIO::setDoseDistCenterPosition	(	float	_center[3],
		int	_num = `0`
	)

Definition at line 3650 of file G4GMocrenIO.cc.

                                                                      {
 
  kDose[_num].setCenterPosition(_center);
}

References kDose.

◆ setDoseDistMinMax() [1/2]

void G4GMocrenIO::setDoseDistMinMax	(	double	_minmax[2],
		int	_num = `0`
	)

Definition at line 3522 of file G4GMocrenIO.cc.

                                                               {
 
  kDose[_num].setMinMax(_minmax);
}  

References kDose.

◆ setDoseDistMinMax() [2/2]

void G4GMocrenIO::setDoseDistMinMax	(	short	_minmax[2],
		int	_num = `0`
	)

Definition at line 3504 of file G4GMocrenIO.cc.

                                                              {
 
  double minmax[2];
  double scale = kDose[_num].getScale();
  for(int i = 0; i < 2; i++) minmax[i] = (double)_minmax[i]*scale;
  kDose[_num].setMinMax(minmax);
}  

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setDoseDistName()

void G4GMocrenIO::setDoseDistName	(	std::string	_name,
		int	_num = `0`
	)

Definition at line 3662 of file G4GMocrenIO.cc.

                                                           {
 
  kDose[_num].setName(_name);
}

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd(), and retrieveData4().

◆ setDoseDistScale()

void G4GMocrenIO::setDoseDistScale	(	double &	_scale,
		int	_num = `0`
	)

Definition at line 3535 of file G4GMocrenIO.cc.

                                                            {
 
  kDose[_num].setScale(_scale);
}

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setDoseDistSize()

void G4GMocrenIO::setDoseDistSize	(	int	_size[3],
		int	_num = `0`
	)

Definition at line 3497 of file G4GMocrenIO.cc.

                                                        {
 
  kDose[_num].setSize(_size);
 
  //resetDose();
}

References kDose.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setDoseDistUnit()

void G4GMocrenIO::setDoseDistUnit	(	std::string &	_unit,
		int	_num = `0`
	)

Definition at line 3481 of file G4GMocrenIO.cc.

                                                             {
  // to avoid a warning in the compile process
  if(_unit.size() > static_cast<size_t>(_num)) kDoseUnit = _unit;
 
  //char unit[13];
  //std::strncpy(unit, _unit.c_str(), 12);
  //doseUnit = unit;
  kDoseUnit = _unit;
}

References kDoseUnit.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd(), retrieveData3(), and retrieveData4().

◆ setFileName() [1/2]

void G4GMocrenIO::setFileName ( char * _filename )

inline

Definition at line 238 of file G4GMocrenIO.hh.

238{kFileName = _filename;}

References kFileName.

◆ setFileName() [2/2]

void G4GMocrenIO::setFileName ( std::string & _filename )

inline

Definition at line 237 of file G4GMocrenIO.hh.

237{kFileName = _filename;}

References kFileName.

◆ setID() [1/2]

void G4GMocrenIO::setID ( )

Definition at line 3093 of file G4GMocrenIO.cc.

                        {
  time_t t;
  time(&t);
 
  tm * ti;
  ti = localtime(&t);
 
  char cmonth[12][4] = {"Jan", "Feb", "Mar", "Apr",
            "May", "Jun", "Jul", "Aug",
            "Sep", "Oct", "Nov", "Dec"};
  std::stringstream ss;
  ss << std::setfill('0')
     << std::setw(2)
     << ti->tm_hour << ":"
     << std::setw(2)
     << ti->tm_min << ":"
     << std::setw(2)
     << ti->tm_sec << ","
     << cmonth[ti->tm_mon] << "."
     << std::setw(2)
     << ti->tm_mday << ","
     << ti->tm_year+1900;
 
  kId = ss.str();
}

References kId, and G4InuclParticleNames::tm.

◆ setID() [2/2]

void G4GMocrenIO::setID ( std::string & _id )

inline

Definition at line 263 of file G4GMocrenIO.hh.

263{kId = _id;}

References kId.

◆ setLittleEndianInput()

void G4GMocrenIO::setLittleEndianInput ( bool _little )

Definition at line 3124 of file G4GMocrenIO.cc.

3124{kLittleEndianInput = _little;}

References kLittleEndianInput.

◆ setLittleEndianOutput()

void G4GMocrenIO::setLittleEndianOutput ( bool _little )

Definition at line 3125 of file G4GMocrenIO.cc.

3125{kLittleEndianOutput = _little;}

References kLittleEndianOutput.

◆ setModalityCenterPosition()

void G4GMocrenIO::setModalityCenterPosition ( float _center[3] )

Definition at line 3426 of file G4GMocrenIO.cc.

                                                            {
 
  kModality.setCenterPosition(_center);
}

References kModality, and GMocrenDataPrimitive< T >::setCenterPosition().

◆ setModalityImage()

void G4GMocrenIO::setModalityImage ( short * _image )

Definition at line 3382 of file G4GMocrenIO.cc.

                                                 {
 
  kModality.addImage(_image);
}

References GMocrenDataPrimitive< T >::addImage(), and kModality.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setModalityImageDensityMap()

void G4GMocrenIO::setModalityImageDensityMap ( std::vector< float > & _map )

Definition at line 3395 of file G4GMocrenIO.cc.

                                                                    {
  kModalityImageDensityMap = _map;
}

References kModalityImageDensityMap.

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ setModalityImageMinMax()

void G4GMocrenIO::setModalityImageMinMax ( short _minmax[2] )

Definition at line 3402 of file G4GMocrenIO.cc.

                                                         {
 
  kModality.setMinMax(_minmax);
}  

References kModality, and GMocrenDataPrimitive< T >::setMinMax().

Referenced by G4GMocrenFileSceneHandler::BeginSavingGdd().

◆ setModalityImageScale()

void G4GMocrenIO::setModalityImageScale ( double & _scale )

Definition at line 3372 of file G4GMocrenIO.cc.

                                                       {
 
  kModality.setScale(_scale);
}

References kModality, and GMocrenDataPrimitive< T >::setScale().

◆ setModalityImageSize()

void G4GMocrenIO::setModalityImageSize ( int _size[3] )

Definition at line 3366 of file G4GMocrenIO.cc.

                                                   {
 
  kModality.setSize(_size);
}

References kModality, and GMocrenDataPrimitive< T >::setSize().

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ setModalityImageUnit()

void G4GMocrenIO::setModalityImageUnit ( std::string & _unit )

Definition at line 3441 of file G4GMocrenIO.cc.

                                                        {
  kModalityUnit = _unit;
}

References kModalityUnit.

Referenced by retrieveData3(), and retrieveData4().

◆ setModalityImageVoxelSpacing()

void G4GMocrenIO::setModalityImageVoxelSpacing ( float _size[3] )

◆ setNumberOfEvents()

void G4GMocrenIO::setNumberOfEvents ( int & _numberOfEvents )

Definition at line 3139 of file G4GMocrenIO.cc.

                                                         {
  kNumberOfEvents = _numberOfEvents;
}

References kNumberOfEvents.

◆ setPointerToModalityData()

void G4GMocrenIO::setPointerToModalityData ( unsigned int & _pointer )

Definition at line 3147 of file G4GMocrenIO.cc.

                                                                  {
  kPointerToModalityData = _pointer;
}

References kPointerToModalityData.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ setPointerToROIData()

void G4GMocrenIO::setPointerToROIData ( unsigned int & _pointer )

Definition at line 3166 of file G4GMocrenIO.cc.

                                                             {
  kPointerToROIData = _pointer;
}

References kPointerToROIData.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ setPointerToTrackData()

void G4GMocrenIO::setPointerToTrackData ( unsigned int & _pointer )

Definition at line 3173 of file G4GMocrenIO.cc.

                                                               {
  kPointerToTrackData = _pointer;
}

References kPointerToTrackData.

Referenced by calcPointers2(), calcPointers3(), and calcPointers4().

◆ setROI()

void G4GMocrenIO::setROI	(	short *	_image,
		int	_num = `0`
	)

Definition at line 3763 of file G4GMocrenIO.cc.

                                                 {
 
  kRoi[_num].addImage(_image);
}

References kRoi.

◆ setROICenterPosition()

void G4GMocrenIO::setROICenterPosition	(	float	_center[3],
		int	_num = `0`
	)

Definition at line 3799 of file G4GMocrenIO.cc.

                                                                 {
 
  kRoi[_num].setCenterPosition(_center);
}

References kRoi.

◆ setROIMinMax()

void G4GMocrenIO::setROIMinMax	(	short	_minmax[2],
		int	_num = `0`
	)

Definition at line 3787 of file G4GMocrenIO.cc.

                                                         {
 
  kRoi[_num].setMinMax(_minmax);
}

References kRoi.

◆ setROIScale()

void G4GMocrenIO::setROIScale	(	double &	_scale,
		int	_num = `0`
	)

Definition at line 3751 of file G4GMocrenIO.cc.

                                                       {
 
  kRoi[_num].setScale(_scale);
}

References kRoi.

◆ setROISize()

void G4GMocrenIO::setROISize	(	int	_size[3],
		int	_num = `0`
	)

Definition at line 3775 of file G4GMocrenIO.cc.

                                                   {
 
  return kRoi[_num].setSize(_size);
}

References kRoi.

◆ setShortDoseDist()

void G4GMocrenIO::setShortDoseDist	(	short *	_image,
		int	_num = `0`
	)

Definition at line 3556 of file G4GMocrenIO.cc.

                                                           {
 
  int size[3];
  kDose[_num].getSize(size);
  int dsize = size[0]*size[1];
  double * ddata = new double[dsize];
  double scale = kDose[_num].getScale();
  double minmax[2];
  kDose[_num].getMinMax(minmax);
  for(int xy = 0; xy < dsize; xy++) {
    ddata[xy] = _image[xy]*scale;
    if(ddata[xy] < minmax[0]) minmax[0] = ddata[xy];
    if(ddata[xy] > minmax[1]) minmax[1] = ddata[xy];
  }
  kDose[_num].addImage(ddata);
 
  // set min./max.
  kDose[_num].setMinMax(minmax);
}

References kDose.

◆ setTrackColors()

void G4GMocrenIO::setTrackColors ( std::vector< unsigned char * > & _trackColors )

Definition at line 3853 of file G4GMocrenIO.cc.

                                                                          {
  kStepColors = _trackColors;
}

References kStepColors.

◆ setTracks()

void G4GMocrenIO::setTracks ( std::vector< float * > & _tracks )

Definition at line 3844 of file G4GMocrenIO.cc.

                                                        {
  kSteps = _tracks;
}

References kSteps.

◆ setVerboseLevel()

void G4GMocrenIO::setVerboseLevel ( int _level )

Definition at line 4045 of file G4GMocrenIO.cc.

                                            {
  kVerbose = _level;
}

References kVerbose.

◆ setVersion()

void G4GMocrenIO::setVersion ( std::string & _version )

Definition at line 3121 of file G4GMocrenIO.cc.

3121{kVersion = _version;}

References kVersion.

◆ setVoxelSpacing()

void G4GMocrenIO::setVoxelSpacing ( float _spacing[3] )

Definition at line 3128 of file G4GMocrenIO.cc.

                                                   {
  for(int i = 0; i < 3; i++) kVoxelSpacing[i] = _spacing[i];
}

References kVoxelSpacing.

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ storeData() [1/2]

bool G4GMocrenIO::storeData ( )

Definition at line 453 of file G4GMocrenIO.cc.

                            {
  return storeData4();
}

References storeData4().

Referenced by storeData2().

◆ storeData() [2/2]

bool G4GMocrenIO::storeData ( char * _filename )

Definition at line 457 of file G4GMocrenIO.cc.

                                            {
  return storeData4(_filename);
}

References storeData4().

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ storeData2() [1/2]

bool G4GMocrenIO::storeData2 ( )

Definition at line 1331 of file G4GMocrenIO.cc.

                             {
 
  if(kVerbose > 0) G4cout << ">>>>>>>  store data (ver.2) <<<<<<<" << G4endl;
  if(kVerbose > 0) G4cout << "         " << kFileName << G4endl;
 
  bool DEBUG = false;//
 
  // output file open
  std::ofstream ofile(kFileName.c_str(),
              std::ios_base::out|std::ios_base::binary);
 
  // file identifier
  ofile.write("GRAPE    ", 8);
 
  // file version
  unsigned char ver = 0x02;
  ofile.write((char *)&ver, 1);
  // file id for old file format support
  ofile.write(kId.c_str(), IDLENGTH);
  // file version for old file format support
  ofile.write(kVersion.c_str(), VERLENGTH);
  // endian
  ofile.write((char *)&kLittleEndianOutput, sizeof(char));
 
  /*
  // event number
  ofile.write((char *)&numberOfEvents, sizeof(int));
  float imageSpacing[3]; 
  imageSpacing[0] = modalityImageVoxelSpacing[0];
  imageSpacing[1] = modalityImageVoxelSpacing[1];
  imageSpacing[2] = modalityImageVoxelSpacing[2];
  ofile.write((char *)imageSpacing, 12);
  */
 
 
  // voxel spacings for all images
  ofile.write((char *)kVoxelSpacing, 12);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
  calcPointers2();
  // offset from file starting point to the modality image data
  ofile.write((char *)&kPointerToModalityData, 4);
 
  // offset from file starting point to the dose image data
  ofile.write((char *)&kPointerToDoseDistData[0], 4);
 
  // offset from file starting point to the ROI image data
  ofile.write((char *)&kPointerToROIData, 4);
 
  // offset from file starting point to the track data
  ofile.write((char *)&kPointerToTrackData, 4);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", "
          << kPointerToDoseDistData[0] << ", "
          << kPointerToROIData << ", "
          << kPointerToTrackData << G4endl;
  }
 
  //----- modality image -----//
 
  int size[3];
  float scale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
  // modality image size
  kModality.getSize(size);
  ofile.write((char *)size, 3*sizeof(int));
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
 
  // modality image max. & min.
  kModality.getMinMax(minmax);
  ofile.write((char *)minmax, 4);
 
  // modality image unit
  //char munit[13] = "g/cm3       ";
  //ofile.write((char *)&munit, 12);
  
  // modality image scale
  scale = (float)kModality.getScale();
  ofile.write((char *)&scale, 4);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image min., max., scale : "
          << minmax[0] << ", "
          << minmax[1] << ", "
          << scale << G4endl;
  }
 
  // modality image
  int psize = size[0]*size[1];
  if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
  for(int i = 0; i < size[2]; i++) {
    short * image =kModality.getImage(i);
    ofile.write((char *)image, psize*sizeof(short));
 
    if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
  }
  if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
  // modality desity map for CT value
  size_t msize = minmax[1] - minmax[0]+1;
  float * pdmap = new float[msize];
  for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
  ofile.write((char *)pdmap, msize*sizeof(float));
  if(DEBUG || kVerbose > 0) {
    G4cout << "density map : " << std::ends;
    for(int i = 0; i < (int)msize; i+=50)
      G4cout <<kModalityImageDensityMap[i] << ", ";
    G4cout << G4endl;
  }
  delete [] pdmap;
 
 
  //----- dose distribution image -----//
 
  if(!isDoseEmpty()) {
    calcDoseDistScale();
 
    // dose distrbution image size
    kDose[0].getSize(size);
    ofile.write((char *)size, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // dose distribution max. & min.
    getShortDoseDistMinMax(minmax);
    ofile.write((char *)minmax, sizeof(short)*2);
 
    // dose distribution scaling 
    scale = (float)kDose[0].getScale();
    ofile.write((char *)&scale, sizeof(float));
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // dose distribution image
    int dsize = size[0]*size[1];
    short * dimage = new short[dsize];
    for(int z = 0; z < size[2]; z++) {
      getShortDoseDist(dimage, z);
      ofile.write((char *)dimage, dsize*sizeof(short));
 
      if(DEBUG || kVerbose > 0) {
    for(int j = 0; j < dsize; j++) {
      if(dimage[j] < 0)
        G4cout << "[" << j << "," << z << "]"
              << dimage[j] << ", ";
    }
      }
    }
    if(DEBUG || kVerbose > 0) G4cout << G4endl;
    delete [] dimage;
 
    // relative location of the dose distribution image for 
    // the modality image
    kDose[0].getCenterPosition(fCenter);
    for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
    ofile.write((char *)iCenter, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "Dose dist. image relative location : ("
        << iCenter[0] << ", "
        << iCenter[1] << ", "
        << iCenter[2] << ")" << G4endl;
    }
 
  }
 
  //----- ROI image -----//
  if(!isROIEmpty()) {
    // ROI image size
    kRoi[0].getSize(size);
    ofile.write((char *)size, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    kRoi[0].getMinMax(minmax);
    ofile.write((char *)minmax, sizeof(short)*2);
 
    // ROI distribution scaling 
    scale = (float)kRoi[0].getScale();
    ofile.write((char *)&scale, sizeof(float));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    for(int i = 0; i < size[2]; i++) {
      short * rimage = kRoi[0].getImage(i);
      ofile.write((char *)rimage, rsize*sizeof(short));
 
    }
 
    // ROI relative location
    kRoi[0].getCenterPosition(fCenter);
    for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
    ofile.write((char *)iCenter, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << iCenter[0] << ", "
        << iCenter[1] << ", "
        << iCenter[2] << ")" << G4endl;
    }
  }
 
 
  //----- track information -----//
  // track
  int ntrk = kSteps.size();
  ofile.write((char *)&ntrk, sizeof(int));
  if(DEBUG || kVerbose > 0) {
    G4cout << "# of tracks : "
          << ntrk << G4endl;
  }
  for(int i = 0; i < ntrk; i++) {
    float * tp = kSteps[i];
    ofile.write((char *)tp, sizeof(float)*6);
  }
 
 
  // file end mark
  ofile.write("END", 3);
 
  ofile.close();
 
  return true;
}

References calcDoseDistScale(), calcPointers2(), G4FFGEnumerations::DEBUG, G4cout, G4endl, GMocrenDataPrimitive< T >::getImage(), GMocrenDataPrimitive< T >::getMinMax(), GMocrenDataPrimitive< T >::getScale(), getShortDoseDist(), getShortDoseDistMinMax(), GMocrenDataPrimitive< T >::getSize(), IDLENGTH, isDoseEmpty(), isROIEmpty(), kDose, kFileName, kId, kLittleEndianOutput, kModality, kModalityImageDensityMap, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kSteps, kVerbose, kVersion, kVoxelSpacing, ofile, G4InuclParticleNames::tp, and VERLENGTH.

◆ storeData2() [2/2]

bool G4GMocrenIO::storeData2 ( char * _filename )

Definition at line 1589 of file G4GMocrenIO.cc.

                                             {
  kFileName = _filename;
  return storeData();
}

References kFileName, and storeData().

◆ storeData3() [1/2]

bool G4GMocrenIO::storeData3 ( )

Definition at line 1032 of file G4GMocrenIO.cc.

                             {
 
  if(kVerbose > 0) G4cout << ">>>>>>>  store data (ver.3) <<<<<<<" << G4endl;
  if(kVerbose > 0) G4cout << "         " << kFileName << G4endl;
 
  bool DEBUG = false;//
 
  // output file open
  std::ofstream ofile(kFileName.c_str(),
              std::ios_base::out|std::ios_base::binary);
 
  // file identifier
  ofile.write("gMocren ", 8);
 
  // file version
  unsigned char ver = 0x03;
  ofile.write((char *)&ver, 1);
 
  // endian
  ofile.write((char *)&kLittleEndianOutput, sizeof(char));
 
  // comment length (fixed size)
  int commentLength = 1024;
  ofile.write((char *)&commentLength, 4);
 
  // comment 
  char cmt[1025];
  std::strncpy(cmt, kComment.c_str(), 1024);
  ofile.write((char *)cmt, 1024);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Data comment : "
          << kComment << G4endl;
  }
 
  // voxel spacings for all images
  ofile.write((char *)kVoxelSpacing, 12);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
  calcPointers3();
 
  // offset from file starting point to the modality image data
  ofile.write((char *)&kPointerToModalityData, 4);
 
  // # of dose distributions
  //int nDoseDist = (int)pointerToDoseDistData.size();
  int nDoseDist = getNumDoseDist();
  ofile.write((char *)&nDoseDist, 4);
 
  // offset from file starting point to the dose image data
  for(int i = 0; i < nDoseDist; i++) {
    ofile.write((char *)&kPointerToDoseDistData[i], 4);
  }
 
  // offset from file starting point to the ROI image data
  ofile.write((char *)&kPointerToROIData, 4);
 
  // offset from file starting point to the track data
  ofile.write((char *)&kPointerToTrackData, 4);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", ";
    for(int i = 0; i < nDoseDist; i++) {
      G4cout << kPointerToDoseDistData[i] << ", ";
    }
    G4cout << kPointerToROIData << ", "
          << kPointerToTrackData << G4endl;
  }
 
  //----- modality image -----//
 
  int size[3];
  float scale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
  // modality image size
  kModality.getSize(size);
  ofile.write((char *)size, 3*sizeof(int));
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
 
  // modality image max. & min.
  kModality.getMinMax(minmax);
  ofile.write((char *)minmax, 4);
 
  // modality image unit
  char munit[13] = "g/cm3       ";
  ofile.write((char *)munit, 12);
 
  // modality image scale
  scale = (float)kModality.getScale();
  ofile.write((char *)&scale, 4);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image min., max., scale : "
          << minmax[0] << ", "
          << minmax[1] << ", "
          << scale << G4endl;
  }
 
  // modality image
  int psize = size[0]*size[1];
  if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
  for(int i = 0; i < size[2]; i++) {
    short * image = kModality.getImage(i);
    ofile.write((char *)image, psize*sizeof(short));
 
    if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
  }
  if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
  // modality desity map for CT value
  size_t msize = minmax[1] - minmax[0]+1;
  float * pdmap = new float[msize];
  for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
  ofile.write((char *)pdmap, msize*sizeof(float));
  if(DEBUG || kVerbose > 0) {
    G4cout << "density map : " << std::ends;
    for(int i = 0; i < (int)msize; i+=50)
      G4cout <<kModalityImageDensityMap[i] << ", ";
    G4cout << G4endl;
  }
  delete [] pdmap;
 
 
  //----- dose distribution image -----//
 
  if(!isDoseEmpty()) {
 
    calcDoseDistScale();
 
    for(int ndose = 0; ndose < nDoseDist; ndose++) {
      // dose distrbution image size
      kDose[ndose].getSize(size);
      ofile.write((char *)size, 3*sizeof(int));
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose << "] image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
      }
 
      // dose distribution max. & min.
      getShortDoseDistMinMax(minmax, ndose);
      ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
 
      // dose distribution unit
      ofile.write((char *)kDoseUnit.c_str(), 12);
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
      }
 
      // dose distribution scaling 
      double dscale;
      dscale = getDoseDistScale(ndose);
      scale = float(dscale);
      ofile.write((char *)&scale, 4);
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose
          << "] image min., max., scale : "
          << minmax[0] << ", "
          << minmax[1] << ", "
          << scale << G4endl;
      }
 
      // dose distribution image
      int dsize = size[0]*size[1];
      short * dimage = new short[dsize];
      for(int z = 0; z < size[2]; z++) {
    getShortDoseDist(dimage, z, ndose);
    ofile.write((char *)dimage, dsize*2); //sizeof(short)
 
    if(DEBUG || kVerbose > 0) {
      for(int j = 0; j < dsize; j++) {
        if(dimage[j] < 0)
          G4cout << "[" << j << "," << z << "]"
            << dimage[j] << ", ";
      }
    }
      }
      if(DEBUG || kVerbose > 0) G4cout << G4endl;
      delete [] dimage;
 
      // relative location of the dose distribution image for 
      // the modality image
      getDoseDistCenterPosition(fCenter, ndose);
      for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
      ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose
          << "]image relative location : ("
          << iCenter[0] << ", "
          << iCenter[1] << ", "
          << iCenter[2] << ")" << G4endl;
      }
    }
  }
 
  //----- ROI image -----//
  if(!isROIEmpty()) {
    // ROI image size
    kRoi[0].getSize(size);
    ofile.write((char *)size, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    kRoi[0].getMinMax(minmax);
    ofile.write((char *)minmax, sizeof(short)*2);
 
    // ROI distribution scaling 
    scale = (float)kRoi[0].getScale();
    ofile.write((char *)&scale, sizeof(float));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    for(int i = 0; i < size[2]; i++) {
      short * rimage = kRoi[0].getImage(i);
      ofile.write((char *)rimage, rsize*sizeof(short));
 
    }
 
    // ROI relative location
    kRoi[0].getCenterPosition(fCenter);
    for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
    ofile.write((char *)iCenter, 3*sizeof(int));
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << iCenter[0] << ", "
        << iCenter[1] << ", "
        << iCenter[2] << ")" << G4endl;
    }
  }
 
  //----- track information -----//
  // number of track 
  int ntrk = kSteps.size();
  ofile.write((char *)&ntrk, sizeof(int));
  if(DEBUG || kVerbose > 0) {
    G4cout << "# of tracks : "
          << ntrk << G4endl;
  }
  // track position
  for(int i = 0; i < ntrk; i++) {
    float * tp = kSteps[i];
    ofile.write((char *)tp, sizeof(float)*6);
  }
  // track color
  int ntcolor = int(kStepColors.size());
  if(ntrk != ntcolor) 
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "# of track color information must be the same as # of tracks." 
         << G4endl;
  unsigned char white[3] = {255,255,255}; // default color
  for(int i = 0; i < ntrk; i++) {
    if(i < ntcolor) {
      unsigned char * tcolor = kStepColors[i];
      ofile.write((char *)tcolor, 3);
    } else {
      ofile.write((char *)white, 3);
    }
  }
  
  // file end mark
  ofile.write("END", 3);
 
  ofile.close();
 
  return true;
}

References calcDoseDistScale(), calcPointers3(), G4FFGEnumerations::DEBUG, G4VisManager::errors, G4cout, G4endl, getDoseDistCenterPosition(), getDoseDistScale(), GMocrenDataPrimitive< T >::getImage(), GMocrenDataPrimitive< T >::getMinMax(), getNumDoseDist(), GMocrenDataPrimitive< T >::getScale(), getShortDoseDist(), getShortDoseDistMinMax(), GMocrenDataPrimitive< T >::getSize(), G4VisManager::GetVerbosity(), isDoseEmpty(), isROIEmpty(), kComment, kDose, kDoseUnit, kFileName, kLittleEndianOutput, kModality, kModalityImageDensityMap, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kStepColors, kSteps, kVerbose, kVoxelSpacing, ofile, and G4InuclParticleNames::tp.

◆ storeData3() [2/2]

bool G4GMocrenIO::storeData3 ( char * _filename )

◆ storeData4() [1/2]

bool G4GMocrenIO::storeData4 ( )

Definition at line 461 of file G4GMocrenIO.cc.

                             {
 
  bool DEBUG = false;//
 
  if(DEBUG || kVerbose > 0)
    G4cout << ">>>>>>>  store data (ver.4) <<<<<<<" << G4endl;
  if(DEBUG || kVerbose > 0)
    G4cout << "         " << kFileName << G4endl;
 
  // output file open
  std::ofstream ofile(kFileName.c_str(),
              std::ios_base::out|std::ios_base::binary);
  if(DEBUG || kVerbose > 0)
    G4cout << "         file open status: " << ofile.rdbuf() << G4endl;
  
  // file identifier
  ofile.write("gMocren ", 8);
 
  // file version
  unsigned char ver = 0x04;
  ofile.write((char *)&ver, 1);
 
  // endian
  //ofile.write((char *)&kLittleEndianOutput, sizeof(char));
  char littleEndian = 0x01;
  ofile.write((char *)&littleEndian, sizeof(char));
  if(DEBUG || kVerbose > 0) {
    //G4cout << "Endian: " << (int)kLittleEndianOutput << G4endl;
    G4cout << "Endian: " << (int)littleEndian << G4endl;
  }
 
  // for inverting the byte order
  float ftmp[6];
  int itmp[6];
  short stmp[6];
 
  // comment length (fixed size)
  int commentLength = 1024;
  if(kLittleEndianOutput) {
    ofile.write((char *)&commentLength, 4);
  } else {
    invertByteOrder((char *)&commentLength, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  // comment 
  char cmt[1025];
  std::strncpy(cmt, kComment.c_str(), 1024);
  cmt[1024] = '\0';
  ofile.write(cmt, 1024);
  if(DEBUG || kVerbose > 0) {
    G4cout << "Data comment : "
          << kComment << G4endl;
  }
 
  // voxel spacings for all images
  if(kLittleEndianOutput) {
    ofile.write((char *)kVoxelSpacing, 12);
  } else {
    for(int j = 0; j < 3; j++)
      invertByteOrder((char *)&kVoxelSpacing[j], ftmp[j]);
    ofile.write((char *)ftmp, 12);
  }
  if(DEBUG || kVerbose > 0) {
    G4cout << "Voxel spacing : ("
          << kVoxelSpacing[0] << ", "
          << kVoxelSpacing[1] << ", "
          << kVoxelSpacing[2]
          << ") mm " << G4endl;
  }
 
  calcPointers4();
  if(!kTracksWillBeStored) kPointerToTrackData = 0;
 
  // offset from file starting point to the modality image data
  if(kLittleEndianOutput) {
    ofile.write((char *)&kPointerToModalityData, 4);
  } else {
    invertByteOrder((char *)&kPointerToModalityData, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  // # of dose distributions
  //int nDoseDist = (int)pointerToDoseDistData.size();
  int nDoseDist = getNumDoseDist();
  if(kLittleEndianOutput) {
    ofile.write((char *)&nDoseDist, 4);
  } else {
    invertByteOrder((char *)&nDoseDist, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  // offset from file starting point to the dose image data
  if(kLittleEndianOutput) {
    for(int i = 0; i < nDoseDist; i++) {
      ofile.write((char *)&kPointerToDoseDistData[i], 4);
    }
  } else {
    for(int i = 0; i < nDoseDist; i++) {
      invertByteOrder((char *)&kPointerToDoseDistData[i], itmp[0]);
      ofile.write((char *)itmp, 4);
    }
  }
 
  // offset from file starting point to the ROI image data
  if(kLittleEndianOutput) {
    ofile.write((char *)&kPointerToROIData, 4);
  } else {
    invertByteOrder((char *)&kPointerToROIData, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  // offset from file starting point to the track data
  if(kLittleEndianOutput) {
    ofile.write((char *)&kPointerToTrackData, 4);
  } else {
    invertByteOrder((char *)&kPointerToTrackData, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  // offset from file starting point to the detector data
  if(kLittleEndianOutput) {
    ofile.write((char *)&kPointerToDetectorData, 4);
  } else {
    invertByteOrder((char *)&kPointerToDetectorData, itmp[0]);
    ofile.write((char *)itmp, 4);
  }
 
  if(DEBUG || kVerbose > 0) {
    G4cout << "Each pointer to data : "
          << kPointerToModalityData << ", ";
    for(int i = 0; i < nDoseDist; i++) {
      G4cout << kPointerToDoseDistData[i] << ", ";
    }
    G4cout << kPointerToROIData << ", "
          << kPointerToTrackData << ", "
          << kPointerToDetectorData
          << G4endl;
  }
 
  //----- modality image -----//
 
  int size[3];
  float scale;
  short minmax[2];
  float fCenter[3];
  int iCenter[3];
  // modality image size
  kModality.getSize(size);
 
  if(kLittleEndianOutput) {
    ofile.write((char *)size, 3*sizeof(int));
  } else {
    for(int j = 0; j < 3; j++)
      invertByteOrder((char *)&size[j], itmp[j]);
    ofile.write((char *)itmp, 12);
  }
 
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
  }
 
  // modality image max. & min.
  kModality.getMinMax(minmax);
  if(kLittleEndianOutput) {
    ofile.write((char *)minmax, 4);
  } else {
    for(int j = 0; j < 2; j++)
      invertByteOrder((char *)&minmax[j], stmp[j]);
    ofile.write((char *)stmp, 4);
  }
 
  // modality image unit
  char munit[13] = "g/cm3\0";
  ofile.write((char *)munit, 12);
 
  // modality image scale
  scale = (float)kModality.getScale();
  if(kLittleEndianOutput) {
    ofile.write((char *)&scale, 4);
  } else {
    invertByteOrder((char *)&scale, ftmp[0]);
    ofile.write((char *)ftmp, 4);
  }
  if(DEBUG || kVerbose > 0) {
    G4cout << "Modality image min., max., scale : "
          << minmax[0] << ", "
          << minmax[1] << ", "
          << scale << G4endl;
  }
 
  // modality image
  int psize = size[0]*size[1];
  if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
  for(int i = 0; i < size[2]; i++) {
    short * image = kModality.getImage(i);
    if(kLittleEndianOutput) {
      ofile.write((char *)image, psize*sizeof(short));
    } else {
      for(int j = 0; j < psize; j++) {
    invertByteOrder((char *)&image[j], stmp[0]);
    ofile.write((char *)stmp, 2);
      }
    }
 
    if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
  }
  if(DEBUG || kVerbose > 0) G4cout << G4endl;
 
  // modality desity map for CT value
  size_t msize = minmax[1] - minmax[0]+1;
  if(DEBUG || kVerbose > 0) 
    G4cout << "modality image : " << minmax[0] << ", " << minmax[1] << G4endl;
  float * pdmap = new float[msize];
  for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
 
  if(kLittleEndianOutput) {
    ofile.write((char *)pdmap, msize*sizeof(float));
  } else {
    for(int j = 0; j < (int)msize; j++) {
      invertByteOrder((char *)&pdmap[j], ftmp[0]);
      ofile.write((char *)ftmp, 4);
    }
  }
 
  if(DEBUG || kVerbose > 0) {
    G4cout << "density map : " << std::ends;
    for(int i = 0; i < (int)msize; i+=50)
      G4cout <<kModalityImageDensityMap[i] << ", ";
    G4cout << G4endl;
  }
  delete [] pdmap;
 
 
  //----- dose distribution image -----//
 
  if(!isDoseEmpty()) {
 
    calcDoseDistScale();
 
    for(int ndose = 0; ndose < nDoseDist; ndose++) {
      // dose distrbution image size
      kDose[ndose].getSize(size);
      if(kLittleEndianOutput) {
    ofile.write((char *)size, 3*sizeof(int));
      } else {
    for(int j = 0; j < 3; j++)
      invertByteOrder((char *)&size[j], itmp[j]);
    ofile.write((char *)itmp, 12);
      }
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose << "] image size : ("
          << size[0] << ", "
          << size[1] << ", "
          << size[2] << ")"
          << G4endl;
      }
 
      // dose distribution max. & min.
      getShortDoseDistMinMax(minmax, ndose);
      if(kLittleEndianOutput) {
    ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
      } else {
    for(int j = 0; j < 2; j++)
      invertByteOrder((char *)&minmax[j], stmp[j]);
    ofile.write((char *)stmp, 4);
      }
 
      // dose distribution unit
      char cdunit[13];
      std::strncpy(cdunit, kDoseUnit.c_str(), 12);
      cdunit[12] = '\0';
      ofile.write(cdunit, 12);
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
      }
 
      // dose distribution scaling 
      double dscale;
      dscale = getDoseDistScale(ndose);
      scale = float(dscale);
      if(kLittleEndianOutput) {
    ofile.write((char *)&scale, 4);
      } else {
    invertByteOrder((char *)&scale, ftmp[0]);
    ofile.write((char *)ftmp, 4);
      }
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose
          << "] image min., max., scale : "
          << minmax[0] << ", "
          << minmax[1] << ", "
          << scale << G4endl;
      }
 
      // dose distribution image
      int dsize = size[0]*size[1];
      short * dimage = new short[dsize];
      for(int z = 0; z < size[2]; z++) {
    getShortDoseDist(dimage, z, ndose);
    if(kLittleEndianOutput) {
      ofile.write((char *)dimage, dsize*2); //sizeof(short)
    } else {
      for(int j = 0; j < dsize; j++) {
        invertByteOrder((char *)&dimage[j], stmp[0]);
        ofile.write((char *)stmp, 2);
      }
    }
 
    if(DEBUG || kVerbose > 0) {
      for(int j = 0; j < dsize; j++) {
        if(dimage[j] < 0)
          G4cout << "[" << j << "," << z << "]"
            << dimage[j] << ", ";
      }
    }
      }
      if(DEBUG || kVerbose > 0) G4cout << G4endl;
      delete [] dimage;
 
      // relative location of the dose distribution image for 
      // the modality image
      getDoseDistCenterPosition(fCenter, ndose);
      for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
      if(kLittleEndianOutput) {
    ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
      } else {
    for(int j = 0; j < 3; j++)
      invertByteOrder((char *)&iCenter[j], itmp[j]);
    ofile.write((char *)itmp, 12);
      }
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. [" << ndose
          << "]image relative location : ("
          << iCenter[0] << ", "
          << iCenter[1] << ", "
          << iCenter[2] << ")" << G4endl;
      }
 
      // dose distribution name
      std::string name = getDoseDistName(ndose);
      if(name.size() == 0) name = "dose";
      name.resize(80);
      ofile.write((char *)name.c_str(), 80);
      if(DEBUG || kVerbose > 0) {
    G4cout << "Dose dist. name : " << name << G4endl;
      }
 
    }
  }
 
  //----- ROI image -----//
  if(!isROIEmpty()) {
    // ROI image size
    kRoi[0].getSize(size);
    if(kLittleEndianOutput) {
      ofile.write((char *)size, 3*sizeof(int));
    } else {
      for(int j = 0; j < 3; j++)
    invertByteOrder((char *)&size[j], itmp[j]);
      ofile.write((char *)itmp, 12);
    }
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image size : ("
        << size[0] << ", "
        << size[1] << ", "
        << size[2] << ")"
        << G4endl;
    }
 
    // ROI max. & min.
    kRoi[0].getMinMax(minmax);
    if(kLittleEndianOutput) {
      ofile.write((char *)minmax, sizeof(short)*2);
    } else {
      for(int j = 0; j < 2; j++)
    invertByteOrder((char *)&minmax[j], stmp[j]);
      ofile.write((char *)stmp, 4);
    }
 
    // ROI distribution scaling 
    scale = (float)kRoi[0].getScale();
    if(kLittleEndianOutput) {
      ofile.write((char *)&scale, sizeof(float));
    } else {
      invertByteOrder((char *)&scale, ftmp[0]);
      ofile.write((char *)ftmp, 4);
    }
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image min., max., scale : "
        << minmax[0] << ", "
        << minmax[1] << ", "
        << scale << G4endl;
    }
 
    // ROI image
    int rsize = size[0]*size[1];
    for(int i = 0; i < size[2]; i++) {
      short * rimage = kRoi[0].getImage(i);
      if(kLittleEndianOutput) {
    ofile.write((char *)rimage, rsize*sizeof(short));
      } else {
    for(int j = 0; j < rsize; j++) {
      invertByteOrder((char *)&rimage[j], stmp[0]);
      ofile.write((char *)stmp, 2);
    }
      }
 
    }
 
    // ROI relative location
    kRoi[0].getCenterPosition(fCenter);
    for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
    if(kLittleEndianOutput) {
      ofile.write((char *)iCenter, 3*sizeof(int));
    } else {
      for(int j = 0; j < 3; j++)
    invertByteOrder((char *)&iCenter[j], itmp[j]);
      ofile.write((char *)itmp, 12);
    }
    if(DEBUG || kVerbose > 0) {
      G4cout << "ROI image relative location : ("
        << iCenter[0] << ", "
        << iCenter[1] << ", "
        << iCenter[2] << ")" << G4endl;
    }
  }
 
  //----- track information -----//
  // number of track 
  if(kPointerToTrackData > 0) {
 
    int ntrk = kTracks.size();
    if(kLittleEndianOutput) {
      ofile.write((char *)&ntrk, sizeof(int));
    } else {
      invertByteOrder((char *)&ntrk, itmp[0]);
      ofile.write((char *)itmp, 4);
    }
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of tracks : "
        << ntrk << G4endl;
    }
 
    for(int nt = 0; nt < ntrk; nt++) {
 
      // # of steps in a track
      int nsteps = kTracks[nt].getNumberOfSteps();
      if(kLittleEndianOutput) {
    ofile.write((char *)&nsteps, sizeof(int));
      } else {
    invertByteOrder((char *)&nsteps, itmp[0]);
    ofile.write((char *)itmp, 4);
      }
      if(DEBUG || kVerbose > 0) {
    G4cout << "# of steps : " << nsteps << G4endl;
      }
 
      // track color
      unsigned char tcolor[3];
      kTracks[nt].getColor(tcolor);
      ofile.write((char *)tcolor, 3);
 
      // steps
      float stepPoints[6];
      for(int isteps = 0; isteps < nsteps; isteps++) {
    kTracks[nt].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
                stepPoints[3], stepPoints[4], stepPoints[5],
                isteps);
 
    if(kLittleEndianOutput) {
      ofile.write((char *)stepPoints, sizeof(float)*6);
    } else {
      for(int j = 0; j < 6; j++)
        invertByteOrder((char *)&stepPoints[j], ftmp[j]);
      ofile.write((char *)ftmp, 24);
    }
      }
    }
  }
 
  //----- detector information -----//
  // number of detectors
  if(kPointerToDetectorData > 0) {
    int ndet = kDetectors.size();
    if(kLittleEndianOutput) {
      ofile.write((char *)&ndet, sizeof(int));
    } else {
      invertByteOrder((char *)&ndet, itmp[0]);
      ofile.write((char *)itmp, 4);
    }
    if(DEBUG || kVerbose > 0) {
      G4cout << "# of detectors : "
        << ndet << G4endl;
    }
 
    for(int nd = 0; nd < ndet; nd++) {
 
      // # of edges of a detector
      int nedges = kDetectors[nd].getNumberOfEdges();
      if(kLittleEndianOutput) {
    ofile.write((char *)&nedges, sizeof(int));
      } else {
    invertByteOrder((char *)&nedges, itmp[0]);
    ofile.write((char *)itmp, 4);
      }
      if(DEBUG || kVerbose > 0) {
    G4cout << "# of edges in a detector : " << nedges << G4endl;
      }
 
      // edges
      float edgePoints[6];
      for(int ne = 0; ne < nedges; ne++) {
    kDetectors[nd].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
                   edgePoints[3], edgePoints[4], edgePoints[5],
                   ne);
 
    if(kLittleEndianOutput) {
      ofile.write((char *)edgePoints, sizeof(float)*6);
    } else {
      for(int j = 0; j < 6; j++)
        invertByteOrder((char *)&edgePoints[j], ftmp[j]);
      ofile.write((char *)ftmp, 24);
    }
 
    if(DEBUG || kVerbose > 0) {
      if(ne < 1) {
        G4cout << " edge : (" << edgePoints[0] << ", "
              << edgePoints[1] << ", "
              << edgePoints[2] << ") - ("
              << edgePoints[3] << ", "
              << edgePoints[4] << ", "
              << edgePoints[5] << ")" << G4endl;
      }
    }
      }
 
      // detector color
      unsigned char dcolor[3];
      kDetectors[nd].getColor(dcolor);
      ofile.write((char *)dcolor, 3);
      if(DEBUG || kVerbose > 0) {
    G4cout << " rgb : (" << (int)dcolor[0] << ", "
          << (int)dcolor[1] << ", "
          << (int)dcolor[2] << ")" << G4endl;
      }
 
      // detector name
      std::string dname = kDetectors[nd].getName();
      dname.resize(80);
      ofile.write((char *)dname.c_str(), 80);
      if(DEBUG || kVerbose > 0) {
    G4cout << " detector name : " << dname << G4endl;
      
      }
    }
  }
 
  // file end mark
  ofile.write("END", 3);
 
  ofile.close();
  if(DEBUG || kVerbose > 0)
    G4cout << ">>>> closed gdd file: " << kFileName << G4endl;
 
  return true;
}

References calcDoseDistScale(), calcPointers4(), G4FFGEnumerations::DEBUG, G4cout, G4endl, getDoseDistCenterPosition(), getDoseDistName(), getDoseDistScale(), GMocrenDataPrimitive< T >::getImage(), GMocrenDataPrimitive< T >::getMinMax(), getNumDoseDist(), GMocrenDataPrimitive< T >::getScale(), getShortDoseDist(), getShortDoseDistMinMax(), GMocrenDataPrimitive< T >::getSize(), invertByteOrder(), isDoseEmpty(), isROIEmpty(), kComment, kDetectors, kDose, kDoseUnit, kFileName, kLittleEndianOutput, kModality, kModalityImageDensityMap, kPointerToDetectorData, kPointerToDoseDistData, kPointerToModalityData, kPointerToROIData, kPointerToTrackData, kRoi, kTracks, kTracksWillBeStored, kVerbose, kVoxelSpacing, G4InuclParticleNames::name(), and ofile.

Referenced by storeData(), and storeData4().

◆ storeData4() [2/2]

bool G4GMocrenIO::storeData4 ( char * _filename )

Definition at line 1325 of file G4GMocrenIO.cc.

                                             {
  kFileName = _filename;
  return storeData4();
}

References kFileName, and storeData4().

◆ translateDetector()

void G4GMocrenIO::translateDetector ( std::vector< float > & _translate )

Definition at line 4000 of file G4GMocrenIO.cc.

                                                                 {
  std::vector<class GMocrenDetector>::iterator itr = kDetectors.begin();
  for(; itr != kDetectors.end(); itr++) {
    itr->translate(_translate);
  }
}

References kDetectors.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

◆ translateTracks()

void G4GMocrenIO::translateTracks ( std::vector< float > & _translateo )

Definition at line 3934 of file G4GMocrenIO.cc.

                                                               {
  std::vector<class GMocrenTrack>::iterator itr = kTracks.begin();
  for(; itr != kTracks.end(); itr++) {
    itr->translate(_translate);
  }
}

References kTracks.

Referenced by G4GMocrenFileSceneHandler::EndSavingGdd().

Field Documentation

◆ kComment

std::string G4GMocrenIO::kComment

static

Definition at line 181 of file G4GMocrenIO.hh.

Referenced by getComment(), initialize(), retrieveData3(), retrieveData4(), setComment(), storeData3(), and storeData4().

◆ kDetectors

std::vector< class GMocrenDetector > G4GMocrenIO::kDetectors

static

Definition at line 222 of file G4GMocrenIO.hh.

Referenced by addDetector(), calcPointers4(), clearDetector(), getDetector(), getNumberOfDetectors(), storeData4(), and translateDetector().

◆ kDose

std::vector< class GMocrenDataPrimitive< double > > G4GMocrenIO::kDose

static

◆ kDoseUnit

std::string G4GMocrenIO::kDoseUnit = "keV "

static

Definition at line 209 of file G4GMocrenIO.hh.

Referenced by getDoseDistUnit(), initialize(), retrieveData3(), retrieveData4(), setDoseDistUnit(), storeData3(), and storeData4().

◆ kFileName

std::string G4GMocrenIO::kFileName = "dose.gdd"

static

Definition at line 175 of file G4GMocrenIO.hh.

Referenced by getFileName(), initialize(), retrieveData(), retrieveData2(), retrieveData3(), retrieveData4(), setFileName(), storeData2(), storeData3(), and storeData4().

◆ kId

std::string G4GMocrenIO::kId

static

Definition at line 169 of file G4GMocrenIO.hh.

Referenced by getID(), initialize(), retrieveData2(), setID(), and storeData2().

◆ kLittleEndianInput

char G4GMocrenIO::kLittleEndianInput = true

static

Definition at line 178 of file G4GMocrenIO.hh.

Referenced by convertEndian(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), and setLittleEndianInput().

◆ kLittleEndianOutput

char G4GMocrenIO::kLittleEndianOutput = true

static

Definition at line 179 of file G4GMocrenIO.hh.

Referenced by convertEndian(), initialize(), setLittleEndianOutput(), storeData2(), storeData3(), and storeData4().

◆ kModality

class GMocrenDataPrimitive< short > G4GMocrenIO::kModality

static

◆ kModalityImageDensityMap

std::vector< float > G4GMocrenIO::kModalityImageDensityMap

static

Definition at line 203 of file G4GMocrenIO.hh.

Referenced by convertDensityToHU(), getModalityImageDensityMap(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setModalityImageDensityMap(), storeData2(), storeData3(), and storeData4().

◆ kModalityUnit

std::string G4GMocrenIO::kModalityUnit = "g/cm3 "

static

Definition at line 204 of file G4GMocrenIO.hh.

Referenced by getModalityImageUnit(), initialize(), and setModalityImageUnit().

◆ kNumberOfEvents

int G4GMocrenIO::kNumberOfEvents = 0

static

Definition at line 184 of file G4GMocrenIO.hh.

Referenced by addOneEvent(), getNumberOfEvents(), initialize(), and setNumberOfEvents().

◆ kPointerToDetectorData

unsigned int G4GMocrenIO::kPointerToDetectorData = 0

static

Definition at line 195 of file G4GMocrenIO.hh.

Referenced by calcPointers4(), retrieveData4(), and storeData4().

◆ kPointerToDoseDistData

std::vector< unsigned int > G4GMocrenIO::kPointerToDoseDistData

static

Definition at line 189 of file G4GMocrenIO.hh.

Referenced by addPointerToDoseDistData(), calcPointers2(), calcPointers3(), calcPointers4(), getPointerToDoseDistData(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), storeData2(), storeData3(), and storeData4().

◆ kPointerToModalityData

unsigned int G4GMocrenIO::kPointerToModalityData = 0

static

Definition at line 187 of file G4GMocrenIO.hh.

Referenced by getPointerToModalityData(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setPointerToModalityData(), storeData2(), storeData3(), and storeData4().

◆ kPointerToROIData

unsigned int G4GMocrenIO::kPointerToROIData = 0

static

Definition at line 191 of file G4GMocrenIO.hh.

Referenced by getPointerToROIData(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setPointerToROIData(), storeData2(), storeData3(), and storeData4().

◆ kPointerToTrackData

unsigned int G4GMocrenIO::kPointerToTrackData = 0

static

Definition at line 193 of file G4GMocrenIO.hh.

Referenced by calcPointers4(), getPointerToTrackData(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setPointerToTrackData(), storeData2(), storeData3(), and storeData4().

◆ kRoi

std::vector< class GMocrenDataPrimitive< short > > G4GMocrenIO::kRoi

static

Definition at line 212 of file G4GMocrenIO.hh.

Referenced by clearROIAll(), getNumROI(), getROI(), getROICenterPosition(), getROIMinMax(), getROIScale(), getROISize(), initialize(), isROIEmpty(), newROI(), retrieveData2(), retrieveData3(), retrieveData4(), setROI(), setROICenterPosition(), setROIMinMax(), setROIScale(), setROISize(), storeData2(), storeData3(), and storeData4().

◆ kStepColors

std::vector< unsigned char * > G4GMocrenIO::kStepColors

static

Definition at line 216 of file G4GMocrenIO.hh.

Referenced by addTrackColor(), copyTracks(), getTrackColors(), initialize(), setTrackColors(), and storeData3().

◆ kSteps

std::vector< float * > G4GMocrenIO::kSteps

static

Definition at line 215 of file G4GMocrenIO.hh.

Referenced by addTrack(), copyTracks(), getNumTracks(), getTracks(), initialize(), retrieveData2(), setTracks(), storeData2(), and storeData3().

◆ kTracks

std::vector< class GMocrenTrack > G4GMocrenIO::kTracks

static

Definition at line 218 of file G4GMocrenIO.hh.

Referenced by addTrack(), calcPointers4(), clearTracks(), getNumTracks4(), getTrack(), storeData4(), and translateTracks().

◆ kTracksWillBeStored

bool G4GMocrenIO::kTracksWillBeStored

Definition at line 219 of file G4GMocrenIO.hh.

Referenced by initialize(), notStoredTracks(), and storeData4().

◆ kVerbose

int G4GMocrenIO::kVerbose = 0

static

Definition at line 225 of file G4GMocrenIO.hh.

Referenced by calcPointers4(), initialize(), mergeDoseDist(), retrieveData2(), retrieveData3(), retrieveData4(), setVerboseLevel(), storeData2(), storeData3(), and storeData4().

◆ kVersion

std::string G4GMocrenIO::kVersion = "2.0.0"

static

Definition at line 172 of file G4GMocrenIO.hh.

Referenced by getVersion(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setVersion(), and storeData2().

◆ kVoxelSpacing

float G4GMocrenIO::kVoxelSpacing = {0., 0., 0.}

static

Definition at line 198 of file G4GMocrenIO.hh.

Referenced by getVoxelSpacing(), initialize(), retrieveData2(), retrieveData3(), retrieveData4(), setVoxelSpacing(), storeData2(), storeData3(), and storeData4().

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

source/visualization/gMocren/include/G4GMocrenIO.hh
source/visualization/gMocren/src/G4GMocrenIO.cc

Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4GMocrenIO()

◆ ~G4GMocrenIO()

Member Function Documentation

◆ addDetector()

◆ addDoseDist()

◆ addOneEvent()

◆ addPointerToDoseDistData()

◆ addTrack() [1/2]

◆ addTrack() [2/2]

◆ addTrackColor()

◆ calcDoseDistScale()

◆ calcPointers2()

◆ calcPointers3()

◆ calcPointers4()

◆ clearDetector()

◆ clearDoseDistAll()

◆ clearModalityImage()

◆ clearROIAll()

◆ clearTracks()

◆ convertDensityToHU()

◆ convertEndian() [1/2]

◆ convertEndian() [2/2]

◆ copyDoseDist()

◆ copyTracks()

◆ getComment()

◆ getDetector()

◆ getDoseDist()

◆ getDoseDistCenterPosition()

◆ getDoseDistMinMax() [1/2]

◆ getDoseDistMinMax() [2/2]

◆ getDoseDistName()

◆ getDoseDistScale()

◆ getDoseDistSize()

◆ getDoseDistUnit()

◆ getFileName()

◆ getID()

◆ getModalityCenterPosition()

◆ getModalityImage()

◆ getModalityImageDensityMap()

◆ getModalityImageMax()

◆ getModalityImageMin()

◆ getModalityImageMinMax()

◆ getModalityImageScale()

◆ getModalityImageSize()

◆ getModalityImageUnit()

◆ getModalityImageVoxelSpacing()

◆ getNumberOfDetectors()

◆ getNumberOfEvents()

◆ getNumDoseDist()

◆ getNumROI()

◆ getNumTracks()

◆ getNumTracks4()

◆ getPointerToDoseDistData()

◆ getPointerToModalityData()

◆ getPointerToROIData()

◆ getPointerToTrackData()

◆ getROI()

◆ getROICenterPosition()

◆ getROIMinMax()

◆ getROIScale()

◆ getROISize()

◆ getShortDoseDist()

◆ getShortDoseDistMinMax()

◆ getTrack()

◆ getTrackColors()

◆ getTracks()

◆ getVersion()

◆ getVoxelSpacing()

◆ initialize()

◆ invertByteOrder()

◆ isDoseEmpty()

◆ isROIEmpty()

◆ mergeDoseDist()