| Geant4 Cross Reference |
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 //
50 template <typename T> class GMocrenDataPrimitive {
51 protected:
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
60 public:
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 //
91 class GMocrenTrack {
92 public:
93 struct Step {
94 float startPoint[3];
95 float endPoint[3];
96 };
97 protected:
98 std::vector<struct Step> kTrack;
99 unsigned char kColor[3];
100
101 public:
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 //
127 class GMocrenDetector {
128 public:
129 struct Edge {
130 float startPoint[3];
131 float endPoint[3];
132 };
133 protected:
134 std::vector<struct Edge> kDetector;
135 unsigned char kColor[3];
136 std::string kName;
137
138 public:
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 //
166 class G4GMocrenIO {
167 public:
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
227 public:
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();
299 private:
300 // calculate pointers
301 void calcPointers4();
302 void calcPointers3();
303 void calcPointers2();
304
305
306 //----- Modality image -----//
307 public:
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();
385 protected:
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
391 public:
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();
414 protected:
415 // check whether RoI variable is empty or not
416 bool isROIEmpty();
417
418
419 public:
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
453 protected:
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
460 public:
461 //----- verbose information -----//
462 void setVerboseLevel(int _level);
463
464 };
465
466 #endif
467
468