source: trunk/source/visualization/gMocren/include/G4GMocrenIO.hh @ 1337

Last change on this file since 1337 was 1337, checked in by garnier, 14 years ago

tag geant4.9.4 beta 1 + modifs locales
File size: 15.4 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// File I/O manager class for writing or reading calcuated dose
28// distribution and some event information
29//
30//
31//  Mar. 31, 2009 :  release for the gMocrenFile driver
32//
33//                               Akinori Kimura
34//
35//                               gMocren home page:
36//                               http://geant4.kek.jp/gMocren/
37//
38#ifndef GMOCRENIO_HH
39#define GMOCRENIO_HH
40
41#include <vector>
42#include <string>
43#include <fstream>
44#include <map>
45
46//
47//----- GMocrenDataPrimitive class -----//
48// data primitive class for volume data
49//
50template <typename T> class GMocrenDataPrimitive {
51protected:
52  int kSize[3];
53  double kScale;
54  T kMinmax[2];
55  float kCenter[3];
56  std::vector<T *> kImage;
57  std::string kDataName;
58  //std::vector<std::vector<T>> image;
59
60public:
61  GMocrenDataPrimitive();
62  //GMocrenDataPrimitive(GMocrenDataPrimitive<T> & _prim);
63  ~GMocrenDataPrimitive();
64
65  GMocrenDataPrimitive<T> & operator = (const GMocrenDataPrimitive<T> & _right);
66  GMocrenDataPrimitive<T> & operator + (const GMocrenDataPrimitive<T> & _right);
67  GMocrenDataPrimitive<T> & operator += (const GMocrenDataPrimitive<T> & _right);
68
69  void clear();
70  void clearImage();
71  void setSize(int _size[3]);
72  void getSize(int _size[3]);
73  void setScale(double & _scale);
74  double getScale();
75  void setMinMax(T _minmax[2]);
76  void getMinMax(T _minmax[2]);
77  void setImage(std::vector<T *> & _image);
78  void addImage(T * _image);
79  std::vector<T *> & getImage();
80  T * getImage(int _z);  // get image of each layer
81  void setCenterPosition(float _center[3]);
82  void getCenterPosition(float _center[3]);
83  void setName(std::string & _name);
84  std::string getName();
85};
86
87
88//
89//----- GMocrenTrack class -----//
90//
91class GMocrenTrack {
92public:
93  struct Step {
94    float startPoint[3];
95    float endPoint[3];
96  };
97protected:
98  std::vector<struct Step> kTrack;
99  unsigned char kColor[3];
100
101public:
102  GMocrenTrack();
103  ~GMocrenTrack(){;}
104
105 
106  int getNumberOfSteps() {return (int)kTrack.size();}
107  void addStep(float _startx, float _starty, float _startz,
108               float _endx, float _endy, float _endz);
109  void getStep(float & _startx, float & _starty, float & _startz,
110               float & _endx, float & _endy, float & _endz,
111               int _num);
112  void setTrack(std::vector<struct Step> & _aTrack) {kTrack = _aTrack;}
113  void setColor(unsigned char _color[3]) {
114    for(int i = 0; i < 3; i++) kColor[i] = _color[i];
115  }
116  void getColor(unsigned char _color[3]) {
117    for(int i = 0; i < 3; i++) _color[i] = kColor[i];
118  }
119  void translate(std::vector<float> & _tranlate);
120};
121
122
123
124//
125//----- GMocrenDetector class -----//
126//
127class GMocrenDetector {
128public:
129  struct Edge {
130    float startPoint[3];
131    float endPoint[3];
132  };
133protected:
134  std::vector<struct Edge> kDetector;
135  unsigned char kColor[3];
136  std::string kName;
137
138public:
139  GMocrenDetector();
140  ~GMocrenDetector(){;}
141
142 
143  int getNumberOfEdges() {return (int)kDetector.size();}
144  void addEdge(float _startx, float _starty, float _startz,
145               float _endx, float _endy, float _endz);
146  void getEdge(float & _startx, float & _starty, float & _startz,
147               float & _endx, float & _endy, float & _endz,
148               int _num);
149  void setDetector(std::vector<struct Edge> & _aDetector) {kDetector = _aDetector;}
150  void setColor(unsigned char _color[3]) {
151    for(int i = 0; i < 3; i++) kColor[i] = _color[i];
152  }
153  void getColor(unsigned char _color[3]) {
154    for(int i = 0; i < 3; i++) _color[i] = kColor[i];
155  }
156  void setName(std::string & _name) { kName = _name;}
157  std::string getName() {return kName;}
158
159  void translate(std::vector<float> & _tranlate);
160};
161
162
163//
164//----- G4GMocrenIO class -----//
165//
166class G4GMocrenIO {
167public:
168  // file id
169  static std::string kId;
170
171  // file version
172  static std::string kVersion;
173
174  // data file name
175  static std::string kFileName;
176
177  // file data endian: little or not
178  static char kLittleEndianInput;
179  static char kLittleEndianOutput;
180
181  static std::string kComment;
182
183  // number of events
184  static int kNumberOfEvents;
185
186  // pointer to the modality image data
187  static unsigned int kPointerToModalityData;
188  // pointer to the dose distribution image data
189  static std::vector<unsigned int> kPointerToDoseDistData;
190  // pointer to the ROI image data
191  static unsigned int kPointerToROIData;
192  // pointer to the track data
193  static unsigned int kPointerToTrackData;
194  // pointer to the detector data
195  static unsigned int kPointerToDetectorData;
196
197  // voxel spacing (universal size)
198  static float kVoxelSpacing[3];
199
200  //----- modality image -----//
201  static class GMocrenDataPrimitive<short> kModality;
202  // density map to modality (CT) values
203  static std::vector<float> kModalityImageDensityMap;
204  static std::string kModalityUnit;
205
206  //----- dose distribution -----//
207  static std::vector<class GMocrenDataPrimitive<double> > kDose;
208  //std::vector<short *> kShortDose;
209  static std::string kDoseUnit;
210
211  //----- RoI -----//
212  static std::vector<class GMocrenDataPrimitive<short> > kRoi;
213
214  //----- track information -----//
215  static std::vector<float *> kSteps; // begin (x,y,z), end (x,y,z)
216  static std::vector<unsigned char *> kStepColors; // r, g, b
217
218  static std::vector<class GMocrenTrack> kTracks;
219  bool kTracksWillBeStored;
220
221  //----- detector information -----//
222  static std::vector<class GMocrenDetector> kDetectors;
223
224  //----- verbose information -----//
225  static int kVerbose; // verbose level :  0 - 5 (none - overtalk)
226
227public:
228  // constructor
229  G4GMocrenIO();
230  // destructor
231  ~G4GMocrenIO();
232
233  // initialize
234  void initialize();
235
236  // set the gMocren data file name
237  void setFileName(std::string & _filename) {kFileName = _filename;}
238  void setFileName(char * _filename) {kFileName = _filename;}
239  // get the gMocren data file name
240  std::string & getFileName() {return kFileName;}
241  // store all data in the gMocren data file
242  bool storeData(char * _filename); // interface for version 4
243  bool storeData();
244  bool storeData2(char * _filename); // version 2
245  bool storeData2();
246  bool storeData3(char * _filename); // version 3
247  bool storeData3();
248  bool storeData4(char * _filename); // version 4
249  bool storeData4();
250  // retrieve all data from the gMocren data file
251  bool retrieveData(char * _filename); // interface
252  bool retrieveData();
253  bool retrieveData2(char * _filename); //version 2
254  bool retrieveData2();
255  bool retrieveData3(char * _filename); // version 3
256  bool retrieveData3();
257  bool retrieveData4(char * _filename); // version 4
258  bool retrieveData4();
259   
260  // get & set the file id
261  std::string & getID() {return kId;}
262  void setID();
263  void setID(std::string & _id) {kId = _id;}
264
265  // get & set the file version
266  std::string & getVersion();
267  void setVersion(std::string & _version);
268
269  // set endians of input/output data
270  void setLittleEndianInput(bool _little);
271  void setLittleEndianOutput(bool _little);
272
273  // get & set comment
274  std::string & getComment() {return kComment;}
275  void setComment(std::string & _comment) {kComment = _comment;}
276 
277
278  // voxel spacing
279  void setVoxelSpacing(float _spacing[3]);
280  void getVoxelSpacing(float _spacing[3]);
281
282  // get & set number of events
283  int & getNumberOfEvents();
284  void setNumberOfEvents(int & _numberOfEvents);
285  void addOneEvent();
286
287  // set pointer the modality image data
288  void setPointerToModalityData(unsigned int & _pointer);
289  unsigned int getPointerToModalityData();
290  // set pointer the dose distribution image data
291  void addPointerToDoseDistData(unsigned int & _pointer);
292  unsigned int getPointerToDoseDistData(int _elem = 0);
293  // set pointer the ROI image data
294  void setPointerToROIData(unsigned int & _pointer);
295  unsigned int getPointerToROIData();
296  // set pointer the track data
297  void setPointerToTrackData(unsigned int & _pointer);
298  unsigned int getPointerToTrackData();
299private:
300  // calculate pointers
301  void calcPointers4();
302  void calcPointers3();
303  void calcPointers2();
304
305
306  //----- Modality image -----//
307public:
308  // get & set the modality image size
309  void getModalityImageSize(int _size[3]);
310  void setModalityImageSize(int _size[3]);
311  // get & set the modality image spacing size
312  void getModalityImageVoxelSpacing(float _size[3]); // un-usable
313  void setModalityImageVoxelSpacing(float _size[3]); // un-usable
314  // get & set the modality image size
315  void setModalityImageScale(double & _scale);
316  double getModalityImageScale();
317  // set the modality image in CT
318  void setModalityImage(short * _image);
319  short * getModalityImage(int _z);
320  void clearModalityImage();
321  // set/get the modality image density map
322  void setModalityImageDensityMap(std::vector<float> & _map);
323  std::vector<float> & getModalityImageDensityMap();
324  // set the modality image min./max.
325  void setModalityImageMinMax(short _minmax[2]);
326  // get min. & max. of the modality image
327  void getModalityImageMinMax(short _minmax[2]);
328  short getModalityImageMax();
329  short getModalityImageMin();
330  // set center of the modality image position
331  void setModalityCenterPosition(float _center[3]);
332  void getModalityCenterPosition(float _center[3]);
333  // get & set the modality image unit
334  std::string getModalityImageUnit();
335  void setModalityImageUnit(std::string & _unit);
336
337  short convertDensityToHU(float & _dens);
338
339  //----- Dose distribution -----//
340
341  // instanciate a dose distribution data object
342  void newDoseDist();
343  // get number of dose distribion data
344  int getNumDoseDist();
345  // get & set the dose distribution unit
346  std::string getDoseDistUnit(int _num = 0);
347  void setDoseDistUnit(std::string & _unit, int _num = 0);
348  // get & set the dose distribution image size
349  void getDoseDistSize(int _size[3], int _num = 0);
350  void setDoseDistSize(int _size[3], int _num = 0);
351  // get min. & max. of the dose distribution image
352  void setDoseDistMinMax(short _minmax[2], int _num = 0);
353  void getDoseDistMinMax(short _minmax[2], int _num = 0);
354  // get min. & max. of the dose distribution
355  void setDoseDistMinMax(double _minmax[2], int _num = 0);
356  void getDoseDistMinMax(double _minmax[2], int _num = 0);
357  // get & set scale value of the dose distribution for the image
358  void setDoseDistScale(double & _scale, int _num = 0);
359  double getDoseDistScale(int _num = 0);
360  // set the dose distribution image
361  void setShortDoseDist(short * _image, int _num = 0);
362  void getShortDoseDist(short * _data, int _z, int _num = 0);
363  void getShortDoseDistMinMax(short _minmax[2], int _num = 0);
364  // set the dose distribution
365  void setDoseDist(double * _image, int _num = 0);
366  double * getDoseDist(int _z, int _num = 0);
367  // add another dose ditribution map to this map
368  bool addDoseDist(std::vector<double *> & _image, int _num = 0);
369
370  // get & get center position of calculated dose region
371  void getDoseDistCenterPosition(float _center[3], int _num = 0);
372  void setDoseDistCenterPosition(float _center[3], int _num = 0);
373
374  // get & get name of calculated dose distribution
375  std::string getDoseDistName(int _num = 0);
376  void setDoseDistName(std::string _name, int _num = 0);
377
378  // copy dose distributions
379  void copyDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose);
380  // merge two dose distributions
381  bool mergeDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose);
382
383  // clear all dose distributions
384  void clearDoseDistAll();
385protected:
386  // check whether dose variable is empty or not
387  bool isDoseEmpty();
388  // calcuated scale value to convert dose distribution into image
389  void calcDoseDistScale();
390
391public:
392  //----- RoI -----//
393
394  // instanciate an RoI data object
395  void newROI();
396  // get number of RoI data
397  int getNumROI();
398  // get & set the ROI image scale
399  double getROIScale(int _num = 0);
400  void setROIScale(double & _scale, int _num = 0);
401  // get & set the ROI image
402  short * getROI(int _z, int _num = 0);
403  void setROI(short * _image, int _num = 0);
404  // get & set the ROI image size
405  void getROISize(int _size[3], int _num = 0);
406  void setROISize(int _size[3], int _num = 0);
407  // get & set position of the ROI region center
408  void getROICenterPosition(float _center[3], int _num = 0);
409  void setROICenterPosition(float _center[3], int _num = 0);
410  // get & set the ROI image min. and max.
411  void getROIMinMax(short _minmax[2], int _num = 0);
412  void setROIMinMax(short _minmax[2], int _num = 0);
413  void clearROIAll();
414protected:
415  // check whether RoI variable is empty or not
416  bool isROIEmpty();
417
418
419public:
420  //----- Track -----//
421  // get number of tracks
422  int getNumTracks();
423  int getNumTracks4();
424  // get & set tracks
425  std::vector<float *> & getTracks();
426  void getTrack(int _num, std::vector<float *> & _steps, 
427                std::vector<unsigned char * > & _color);
428  void addTrack(float * _tracks);
429  void setTracks(std::vector<float *> & _tracks);
430  std::vector<unsigned char *> & getTrackColors();
431  void addTrackColor(unsigned char * _colors);
432  void setTrackColors(std::vector<unsigned char *> & _trackColors);
433  void copyTracks(std::vector<float *> & _tracks, std::vector<unsigned char *> & _colors);
434  void mergeTracks(std::vector<float *> & _tracks, std::vector<unsigned char *> & _colors);
435  void addTrack(std::vector<float *> & _steps, unsigned char _color[3]);
436
437  void notStoredTracks() {kTracksWillBeStored = false;};
438  void translateTracks(std::vector<float> & _translateo);
439  void clearTracks() {kTracks.clear();}
440
441
442  //----- Detectors -----//
443  // get number of detectors
444  int getNumberOfDetectors();
445  // add one detector which consists of edges (float[6])
446  void addDetector(std::string & _name, std::vector<float *> & _det, unsigned char _color[3]);
447  void getDetector(int _num, std::vector<float *> & _edges,
448                   std::vector<unsigned char *> & _color,
449                   std::string & _detectorName);
450  void translateDetector(std::vector<float> & _translate);
451  void clearDetector() {kDetectors.clear();}
452
453protected:
454  // endian conversion
455  template <typename Type> void convertEndian(char *, Type &);
456  // byte order inversion
457  template <typename T> void invertByteOrder(char * _val, T & _rval);
458
459
460public:
461  //----- verbose information -----//
462  void setVerboseLevel(int _level);
463
464};
465
466#endif
467
Note: See TracBrowser for help on using the repository browser.