Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
G4GMocrenIO.cc
Go to the documentation of this file.
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// $Id$
28//
29//
30// File I/O manager class for writing or reading calcuated dose
31// distribution and some event information
32//
33// Created: Mar. 31, 2009 Akinori Kimura : release for the gMocrenFile driver
34//
35// Akinori Kimura
36// gMocren home page:
37// http://geant4.kek.jp/gMocren/
38//
39//
40#include "G4GMocrenIO.hh"
41#include <iostream>
42#include <ctime>
43#include <sstream>
44#include <iomanip>
45#include <cstdlib>
46#include <cstring>
47
48#include "globals.hh"
49#include "G4VisManager.hh"
50
51#if defined(_WIN32)
52#define LITTLE_ENDIAN 1234
53#define BYTE_ORDER LITTLE_ENDIAN
54#endif
55
56const int DOSERANGE = 25000;
57
58//----- GMocrenDataPrimitive class in the GMocrenDataIO class-----//
59template <typename T>
60GMocrenDataPrimitive<T>::GMocrenDataPrimitive () {
61 clear();
62}
63template <typename T>
64GMocrenDataPrimitive<T>::~GMocrenDataPrimitive () {
65 /*
66 std::vector<short *>::iterator itr = image.begin();
67 for(; itr != image.end(); itr++) {
68 delete [] *itr;
69 }
70 */
71}
72
73template <typename T> GMocrenDataPrimitive<T> &
74GMocrenDataPrimitive<T>::operator = (const GMocrenDataPrimitive<T> & _right) {
75 for(int i = 0; i < 3; i++) {
76 kSize[i] = _right.kSize[i];
77 kCenter[i] = _right.kCenter[i];
78 }
79 kScale = _right.kScale;
80 for(int i = 0; i < 2; i++) kMinmax[i] = _right.kMinmax[i];
81 int num = kSize[0]*kSize[1];
82 kImage.clear();
83 for(int z = 0; z < kSize[2]; z++) {
84 T * img = new T[num];
85 for(int i = 0; i < num; i++) img[i] =_right.kImage[z][i];
86 kImage.push_back(img);
87 }
88 return *this;
89}
90
91template <typename T> GMocrenDataPrimitive<T> &
92GMocrenDataPrimitive<T>::operator + (const GMocrenDataPrimitive<T> & _right) {
93
94 GMocrenDataPrimitive<T> rprim;
95 bool stat = true;
96 for(int i = 0; i < 3; i++) {
97 if(kSize[i] != _right.kSize[i]) stat = false;
98 if(kCenter[i] != _right.kCenter[i]) stat = false;
99 }
100 if(!stat) {
101 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
102 G4cout << "Warning: operator + "
103 << " Cannot do the operator +"
104 << G4endl;
105 return *this;
106 }
107
108 rprim.setSize(kSize);
109 rprim.setCenterPosition(kCenter);
110
111 T mms[2] = {9e100,-9e100};
112 //if(mms[0] > _right.minmax[0]) mms[0] = _right.minmax[0];
113 //if(mms[1] < _right.minmax[1]) mms[1] = _right.minmax[1];
114
115 int num = kSize[0]*kSize[1];
116 for(int z = 0; z < kSize[2]; z++) {
117 T * img = new T[num];
118 for(int xy = 0; xy < num; xy++) {
119 img[xy] = kImage[z][xy] + _right.kImage[z][xy];
120 if(mms[0] > img[xy]) mms[0] = img[xy];
121 if(mms[1] < img[xy]) mms[1] = img[xy];
122 }
123 rprim.addImage(img);
124 }
125 rprim.setMinMax(mms);
126
127 T scl = mms[1]/DOSERANGE;
128 rprim.setScale(scl);
129
130 return rprim;
131}
132
133template <typename T> GMocrenDataPrimitive<T> &
134GMocrenDataPrimitive<T>::operator += (const GMocrenDataPrimitive<T> & _right) {
135
136 bool stat = true;
137 for(int i = 0; i < 3; i++) {
138 if(kSize[i] != _right.kSize[i]) stat = false;
139 if(kCenter[i] != _right.kCenter[i]) stat = false;
140 }
141 if(!stat) {
142 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
143 G4cout << "Warning: operator += " << G4endl
144 << " Cannot do the operator +="
145 << G4endl;
146 return *this;
147 }
148
149 if(kMinmax[0] > _right.kMinmax[0]) kMinmax[0] = _right.kMinmax[0];
150 if(kMinmax[1] < _right.kMinmax[1]) kMinmax[1] = _right.kMinmax[1];
151
152 int num = kSize[0]*kSize[1];
153 for(int z = 0; z < kSize[2]; z++) {
154 for(int xy = 0; xy < num; xy++) {
155 kImage[z][xy] += _right.kImage[z][xy];
156 if(kMinmax[0] > kImage[z][xy]) kMinmax[0] = kImage[z][xy];
157 if(kMinmax[1] < kImage[z][xy]) kMinmax[1] = kImage[z][xy];
158 }
159 }
160
161 kScale = kMinmax[1]/DOSERANGE;
162
163 return *this;
164}
165
166template <typename T>
167void GMocrenDataPrimitive<T>::clear() {
168 for(int i = 0; i < 3; i++) {
169 kSize[i] = 0;
170 kCenter[i] = 0.;
171 }
172 kScale = 1.;
173 kMinmax[0] = (T)32109;
174 kMinmax[1] = (T)-32109;
175
176 clearImage();
177}
178template <typename T>
179void GMocrenDataPrimitive<T>::clearImage() {
180 typename std::vector<T *>::iterator itr;
181 for(itr = kImage.begin(); itr != kImage.end(); itr++) {
182 delete [] *itr;
183 }
184 kImage.clear();
185}
186template <typename T>
187void GMocrenDataPrimitive<T>::setSize(int _size[3]) {
188 for(int i = 0; i < 3; i++) kSize[i] = _size[i];
189}
190template <typename T>
191void GMocrenDataPrimitive<T>::getSize(int _size[3]) {
192 for(int i = 0; i < 3; i++) _size[i] = kSize[i];
193}
194template <typename T>
195void GMocrenDataPrimitive<T>::setScale(double & _scale) {
196 kScale = _scale;
197}
198template <typename T>
199double GMocrenDataPrimitive<T>::getScale() {
200 return kScale;
201}
202template <typename T>
203void GMocrenDataPrimitive<T>::setMinMax(T _minmax[2]) {
204 for(int i = 0; i < 2; i++) kMinmax[i] = _minmax[i];
205}
206template <typename T>
207void GMocrenDataPrimitive<T>::getMinMax(T _minmax[2]) {
208 for(int i = 0; i < 2; i++) _minmax[i] = kMinmax[i];
209
210}
211template <typename T>
212void GMocrenDataPrimitive<T>::setImage(std::vector<T *> & _image) {
213 kImage = _image;
214}
215template <typename T>
216void GMocrenDataPrimitive<T>::addImage(T * _image) {
217 kImage.push_back(_image);
218}
219template <typename T>
220std::vector<T *> & GMocrenDataPrimitive<T>::getImage() {
221 return kImage;
222}
223template <typename T>
224T * GMocrenDataPrimitive<T>::getImage(int _z) {
225 if(_z >= (int)kImage.size()) return 0;
226 return kImage[_z];
227}
228template <typename T>
229void GMocrenDataPrimitive<T>::setCenterPosition(float _center[3]) {
230 for(int i = 0; i < 3; i++) kCenter[i] = _center[i];
231}
232template <typename T>
233void GMocrenDataPrimitive<T>::getCenterPosition(float _center[3]) {
234 for(int i = 0; i < 3; i++) _center[i] = kCenter[i];
235}
236template <typename T>
237void GMocrenDataPrimitive<T>::setName(std::string & _name) {
238 kDataName = _name;
239}
240template <typename T>
241std::string GMocrenDataPrimitive<T>::getName() {
242 return kDataName;
243}
244
245
246
247
248
249GMocrenTrack::GMocrenTrack() {
250 kTrack.clear();
251 for(int i = 0; i < 3; i++) kColor[i] = 0;
252}
253
254void GMocrenTrack::addStep(float _startx, float _starty, float _startz,
255 float _endx, float _endy, float _endz) {
256 struct Step step;
257 step.startPoint[0] = _startx;
258 step.startPoint[1] = _starty;
259 step.startPoint[2] = _startz;
260 step.endPoint[0] = _endx;
261 step.endPoint[1] = _endy;
262 step.endPoint[2] = _endz;
263 kTrack.push_back(step);
264}
265void GMocrenTrack::getStep(float & _startx, float & _starty, float & _startz,
266 float & _endx, float & _endy, float & _endz,
267 int _num) {
268 if(_num >= (int)kTrack.size()) {
269 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
270 G4cout << "GMocrenTrack::getStep(...) Error: "
271 << "invalid step # : " << _num << G4endl;
272 return;
273 }
274
275 _startx = kTrack[_num].startPoint[0];
276 _starty = kTrack[_num].startPoint[1];
277 _startz = kTrack[_num].startPoint[2];
278 _endx = kTrack[_num].endPoint[0];
279 _endy = kTrack[_num].endPoint[1];
280 _endz = kTrack[_num].endPoint[2];
281}
282void GMocrenTrack::translate(std::vector<float> & _translate) {
283 std::vector<struct Step>::iterator itr = kTrack.begin();
284 for(; itr != kTrack.end(); itr++) {
285 for(int i = 0; i < 3; i++ ) {
286 itr->startPoint[i] += _translate[i];
287 itr->endPoint[i] += _translate[i];
288 }
289 }
290}
291
292
293
294
295
296
297
298
299
300GMocrenDetector::GMocrenDetector() {
301 kDetector.clear();
302 for(int i = 0; i < 3; i++) kColor[i] = 0;
303}
304
305void GMocrenDetector::addEdge(float _startx, float _starty, float _startz,
306 float _endx, float _endy, float _endz) {
307 struct Edge edge;
308 edge.startPoint[0] = _startx;
309 edge.startPoint[1] = _starty;
310 edge.startPoint[2] = _startz;
311 edge.endPoint[0] = _endx;
312 edge.endPoint[1] = _endy;
313 edge.endPoint[2] = _endz;
314 kDetector.push_back(edge);
315}
316void GMocrenDetector::getEdge(float & _startx, float & _starty, float & _startz,
317 float & _endx, float & _endy, float & _endz,
318 int _num) {
319 if(_num >= (int)kDetector.size()) {
320 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
321 G4cout << "GMocrenDetector::getEdge(...) Error: "
322 << "invalid edge # : " << _num << G4endl;
323 return;
324 }
325
326 _startx = kDetector[_num].startPoint[0];
327 _starty = kDetector[_num].startPoint[1];
328 _startz = kDetector[_num].startPoint[2];
329 _endx = kDetector[_num].endPoint[0];
330 _endy = kDetector[_num].endPoint[1];
331 _endz = kDetector[_num].endPoint[2];
332}
333void GMocrenDetector::translate(std::vector<float> & _translate) {
334 std::vector<struct Edge>::iterator itr = kDetector.begin();
335 for(; itr != kDetector.end(); itr++) {
336 for(int i = 0; i < 3; i++) {
337 itr->startPoint[i] += _translate[i];
338 itr->endPoint[i] += _translate[i];
339 }
340 }
341}
342
343
344
345
346
347
348
349
350
351// file information
352std::string G4GMocrenIO::kId;
353std::string G4GMocrenIO::kVersion = "2.0.0";
354int G4GMocrenIO::kNumberOfEvents = 0;
355char G4GMocrenIO::kLittleEndianInput = true;
356
357#if BYTE_ORDER == LITTLE_ENDIAN
358char G4GMocrenIO::kLittleEndianOutput = true;
359#else
360char G4GMocrenIO::kLittleEndianOutput = false; // Big endian
361#endif
362std::string G4GMocrenIO::kComment;
363//
364std::string G4GMocrenIO::kFileName = "dose.gdd";
365
366//
367unsigned int G4GMocrenIO::kPointerToModalityData = 0;
368std::vector<unsigned int> G4GMocrenIO::kPointerToDoseDistData;
369unsigned int G4GMocrenIO::kPointerToROIData = 0;
370unsigned int G4GMocrenIO::kPointerToTrackData = 0;
371unsigned int G4GMocrenIO::kPointerToDetectorData = 0;
372
373// modality
374float G4GMocrenIO::kVoxelSpacing[3] = {0., 0., 0.};
375class GMocrenDataPrimitive<short> G4GMocrenIO::kModality;
376std::vector<float> G4GMocrenIO::kModalityImageDensityMap;
377std::string G4GMocrenIO::kModalityUnit = "g/cm3 "; // 12 Bytes
378
379// dose
380std::vector<class GMocrenDataPrimitive<double> > G4GMocrenIO::kDose;
381std::string G4GMocrenIO::kDoseUnit = "keV "; // 12 Bytes
382
383// ROI
384std::vector<class GMocrenDataPrimitive<short> > G4GMocrenIO::kRoi;
385
386// track
387std::vector<float *> G4GMocrenIO::kSteps;
388std::vector<unsigned char *> G4GMocrenIO::kStepColors;
389std::vector<class GMocrenTrack> G4GMocrenIO::kTracks;
390
391// detector
392std::vector<class GMocrenDetector> G4GMocrenIO::kDetectors;
393
394// verbose
395int G4GMocrenIO::kVerbose = 0;
396
397const int IDLENGTH = 21;
398const int VERLENGTH = 6;
399
400// constructor
401G4GMocrenIO::G4GMocrenIO()
402 : kTracksWillBeStored(true) {
403 ;
404}
405
406// destructor
407G4GMocrenIO::~G4GMocrenIO() {
408 ;
409}
410
411// initialize
412void G4GMocrenIO::initialize() {
413
414 kId.clear();
415 kVersion = "2.0.0";
416 kNumberOfEvents = 0;
417 kLittleEndianInput = true;
418#if BYTE_ORDER == LITTLE_ENDIAN
419 kLittleEndianOutput = true;
420#else // Big endian
421 kLittleEndianOutput = false;
422#endif
423 kComment.clear();
424 kFileName = "dose.gdd";
425 kPointerToModalityData = 0;
426 kPointerToDoseDistData.clear();
427 kPointerToROIData = 0;
428 kPointerToTrackData = 0;
429 // modality
430 for(int i = 0; i < 3; i++) kVoxelSpacing[i] = 0.;
431 kModality.clear();
432 kModalityImageDensityMap.clear();
433 kModalityUnit = "g/cm3 "; // 12 Bytes
434 // dose
435 kDose.clear();
436 kDoseUnit = "keV "; // 12 Bytes
437 // ROI
438 kRoi.clear();
439 // track
440 std::vector<float *>::iterator itr;
441 for(itr = kSteps.begin(); itr != kSteps.end(); itr++) delete [] *itr;
442 kSteps.clear();
443 std::vector<unsigned char *>::iterator citr;
444 for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++)
445 delete [] *citr;
446 kStepColors.clear();
447 kTracksWillBeStored = true;
448
449 // verbose
450 kVerbose = 0;
451}
452
453bool G4GMocrenIO::storeData() {
454 return storeData4();
455}
456//
457bool G4GMocrenIO::storeData(char * _filename) {
458 return storeData4(_filename);
459}
460
461bool G4GMocrenIO::storeData4() {
462
463 bool DEBUG = false;//
464
465 if(DEBUG || kVerbose > 0)
466 G4cout << ">>>>>>> store data (ver.4) <<<<<<<" << G4endl;
467 if(DEBUG || kVerbose > 0)
468 G4cout << " " << kFileName << G4endl;
469
470 // output file open
471 std::ofstream ofile(kFileName.c_str(),
472 std::ios_base::out|std::ios_base::binary);
473 if(DEBUG || kVerbose > 0)
474 G4cout << " file open status: " << ofile << G4endl;
475
476 // file identifier
477 ofile.write("gMocren ", 8);
478
479 // file version
480 unsigned char ver = 0x04;
481 ofile.write((char *)&ver, 1);
482
483 // endian
484 //ofile.write((char *)&kLittleEndianOutput, sizeof(char));
485 char littleEndian = 0x01;
486 ofile.write((char *)&littleEndian, sizeof(char));
487 if(DEBUG || kVerbose > 0) {
488 //G4cout << "Endian: " << (int)kLittleEndianOutput << G4endl;
489 G4cout << "Endian: " << (int)littleEndian << G4endl;
490 }
491
492 // for inverting the byte order
493 float ftmp[6];
494 int itmp[6];
495 short stmp[6];
496
497 // comment length (fixed size)
498 int commentLength = 1024;
499 if(kLittleEndianOutput) {
500 ofile.write((char *)&commentLength, 4);
501 } else {
502 invertByteOrder((char *)&commentLength, itmp[0]);
503 ofile.write((char *)itmp, 4);
504 }
505
506 // comment
507 char cmt[1025];
508 for(int i = 0; i < 1025; i++) cmt[i] = '\0';
509 //std::strncpy(cmt, kComment.c_str(), 1024);
510 const char * cmnt = kComment.c_str();
511 size_t lcm = std::strlen(cmnt);
512 if(lcm > 1024) lcm = 1024;
513 std::strncpy(cmt, cmnt, lcm);
514 ofile.write((char *)cmt, 1024);
515 if(DEBUG || kVerbose > 0) {
516 G4cout << "Data comment : "
517 << kComment << G4endl;
518 }
519
520 // voxel spacings for all images
521 if(kLittleEndianOutput) {
522 ofile.write((char *)kVoxelSpacing, 12);
523 } else {
524 for(int j = 0; j < 3; j++)
525 invertByteOrder((char *)&kVoxelSpacing[j], ftmp[j]);
526 ofile.write((char *)ftmp, 12);
527 }
528 if(DEBUG || kVerbose > 0) {
529 G4cout << "Voxel spacing : ("
530 << kVoxelSpacing[0] << ", "
531 << kVoxelSpacing[1] << ", "
532 << kVoxelSpacing[2]
533 << ") mm " << G4endl;
534 }
535
536 calcPointers4();
537 if(!kTracksWillBeStored) kPointerToTrackData = 0;
538
539 // offset from file starting point to the modality image data
540 if(kLittleEndianOutput) {
541 ofile.write((char *)&kPointerToModalityData, 4);
542 } else {
543 invertByteOrder((char *)&kPointerToModalityData, itmp[0]);
544 ofile.write((char *)itmp, 4);
545 }
546
547 // # of dose distributions
548 //int nDoseDist = (int)pointerToDoseDistData.size();
549 int nDoseDist = getNumDoseDist();
550 if(kLittleEndianOutput) {
551 ofile.write((char *)&nDoseDist, 4);
552 } else {
553 invertByteOrder((char *)&nDoseDist, itmp[0]);
554 ofile.write((char *)itmp, 4);
555 }
556
557 // offset from file starting point to the dose image data
558 if(kLittleEndianOutput) {
559 for(int i = 0; i < nDoseDist; i++) {
560 ofile.write((char *)&kPointerToDoseDistData[i], 4);
561 }
562 } else {
563 for(int i = 0; i < nDoseDist; i++) {
564 invertByteOrder((char *)&kPointerToDoseDistData[i], itmp[0]);
565 ofile.write((char *)itmp, 4);
566 }
567 }
568
569 // offset from file starting point to the ROI image data
570 if(kLittleEndianOutput) {
571 ofile.write((char *)&kPointerToROIData, 4);
572 } else {
573 invertByteOrder((char *)&kPointerToROIData, itmp[0]);
574 ofile.write((char *)itmp, 4);
575 }
576
577 // offset from file starting point to the track data
578 if(kLittleEndianOutput) {
579 ofile.write((char *)&kPointerToTrackData, 4);
580 } else {
581 invertByteOrder((char *)&kPointerToTrackData, itmp[0]);
582 ofile.write((char *)itmp, 4);
583 }
584
585 // offset from file starting point to the detector data
586 if(kLittleEndianOutput) {
587 ofile.write((char *)&kPointerToDetectorData, 4);
588 } else {
589 invertByteOrder((char *)&kPointerToDetectorData, itmp[0]);
590 ofile.write((char *)itmp, 4);
591 }
592
593 if(DEBUG || kVerbose > 0) {
594 G4cout << "Each pointer to data : "
595 << kPointerToModalityData << ", ";
596 for(int i = 0; i < nDoseDist; i++) {
597 G4cout << kPointerToDoseDistData[i] << ", ";
598 }
599 G4cout << kPointerToROIData << ", "
600 << kPointerToTrackData << ", "
601 << kPointerToDetectorData
602 << G4endl;
603 }
604
605 //----- modality image -----//
606
607 int size[3];
608 float scale;
609 short minmax[2];
610 float fCenter[3];
611 int iCenter[3];
612 // modality image size
613 kModality.getSize(size);
614
615 if(kLittleEndianOutput) {
616 ofile.write((char *)size, 3*sizeof(int));
617 } else {
618 for(int j = 0; j < 3; j++)
619 invertByteOrder((char *)&size[j], itmp[j]);
620 ofile.write((char *)itmp, 12);
621 }
622
623 if(DEBUG || kVerbose > 0) {
624 G4cout << "Modality image size : ("
625 << size[0] << ", "
626 << size[1] << ", "
627 << size[2] << ")"
628 << G4endl;
629 }
630
631 // modality image max. & min.
632 kModality.getMinMax(minmax);
633 if(kLittleEndianOutput) {
634 ofile.write((char *)minmax, 4);
635 } else {
636 for(int j = 0; j < 2; j++)
637 invertByteOrder((char *)&minmax[j], stmp[j]);
638 ofile.write((char *)stmp, 4);
639 }
640
641 // modality image unit
642 char munit[13] = "g/cm3\0";
643 ofile.write((char *)munit, 12);
644
645 // modality image scale
646 scale = (float)kModality.getScale();
647 if(kLittleEndianOutput) {
648 ofile.write((char *)&scale, 4);
649 } else {
650 invertByteOrder((char *)&scale, ftmp[0]);
651 ofile.write((char *)ftmp, 4);
652 }
653 if(DEBUG || kVerbose > 0) {
654 G4cout << "Modality image min., max., scale : "
655 << minmax[0] << ", "
656 << minmax[1] << ", "
657 << scale << G4endl;
658 }
659
660 // modality image
661 int psize = size[0]*size[1];
662 if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
663 for(int i = 0; i < size[2]; i++) {
664 short * image = kModality.getImage(i);
665 if(kLittleEndianOutput) {
666 ofile.write((char *)image, psize*sizeof(short));
667 } else {
668 for(int j = 0; j < psize; j++) {
669 invertByteOrder((char *)&image[j], stmp[0]);
670 ofile.write((char *)stmp, 2);
671 }
672 }
673
674 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
675 }
676 if(DEBUG || kVerbose > 0) G4cout << G4endl;
677
678 // modality desity map for CT value
679 size_t msize = minmax[1] - minmax[0]+1;
680 if(DEBUG || kVerbose > 0)
681 G4cout << "modality image : " << minmax[0] << ", " << minmax[1] << G4endl;
682 float * pdmap = new float[msize];
683 for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i];
684
685 if(kLittleEndianOutput) {
686 ofile.write((char *)pdmap, msize*sizeof(float));
687 } else {
688 for(int j = 0; j < (int)msize; j++) {
689 invertByteOrder((char *)&pdmap[j], ftmp[0]);
690 ofile.write((char *)ftmp, 4);
691 }
692 }
693
694 if(DEBUG || kVerbose > 0) {
695 G4cout << "density map : " << std::ends;
696 for(int i = 0; i < (int)msize; i+=50)
697 G4cout <<kModalityImageDensityMap[i] << ", ";
698 G4cout << G4endl;
699 }
700 delete [] pdmap;
701
702
703 //----- dose distribution image -----//
704
705 if(!isDoseEmpty()) {
706
707 calcDoseDistScale();
708
709 for(int ndose = 0; ndose < nDoseDist; ndose++) {
710 // dose distrbution image size
711 kDose[ndose].getSize(size);
712 if(kLittleEndianOutput) {
713 ofile.write((char *)size, 3*sizeof(int));
714 } else {
715 for(int j = 0; j < 3; j++)
716 invertByteOrder((char *)&size[j], itmp[j]);
717 ofile.write((char *)itmp, 12);
718 }
719 if(DEBUG || kVerbose > 0) {
720 G4cout << "Dose dist. [" << ndose << "] image size : ("
721 << size[0] << ", "
722 << size[1] << ", "
723 << size[2] << ")"
724 << G4endl;
725 }
726
727 // dose distribution max. & min.
728 getShortDoseDistMinMax(minmax, ndose);
729 if(kLittleEndianOutput) {
730 ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
731 } else {
732 for(int j = 0; j < 2; j++)
733 invertByteOrder((char *)&minmax[j], stmp[j]);
734 ofile.write((char *)stmp, 4);
735 }
736
737 // dose distribution unit
738 char cdunit[13];
739 for(int i = 0; i < 13; i++) cdunit[i] = '\0';
740 const char * cu = kDoseUnit.c_str();
741 size_t lcu = std::strlen(cu);
742 if(lcu > 1024) lcu = 1024;
743 std::strncpy(cdunit, cu, lcu);
744 ofile.write((char *)cdunit, 12);
745 if(DEBUG || kVerbose > 0) {
746 G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
747 }
748
749 // dose distribution scaling
750 double dscale;
751 dscale = getDoseDistScale(ndose);
752 scale = float(dscale);
753 if(kLittleEndianOutput) {
754 ofile.write((char *)&scale, 4);
755 } else {
756 invertByteOrder((char *)&scale, ftmp[0]);
757 ofile.write((char *)ftmp, 4);
758 }
759 if(DEBUG || kVerbose > 0) {
760 G4cout << "Dose dist. [" << ndose
761 << "] image min., max., scale : "
762 << minmax[0] << ", "
763 << minmax[1] << ", "
764 << scale << G4endl;
765 }
766
767 // dose distribution image
768 int dsize = size[0]*size[1];
769 short * dimage = new short[dsize];
770 for(int z = 0; z < size[2]; z++) {
771 getShortDoseDist(dimage, z, ndose);
772 if(kLittleEndianOutput) {
773 ofile.write((char *)dimage, dsize*2); //sizeof(short)
774 } else {
775 for(int j = 0; j < dsize; j++) {
776 invertByteOrder((char *)&dimage[j], stmp[0]);
777 ofile.write((char *)stmp, 2);
778 }
779 }
780
781 if(DEBUG || kVerbose > 0) {
782 for(int j = 0; j < dsize; j++) {
783 if(dimage[j] < 0)
784 G4cout << "[" << j << "," << z << "]"
785 << dimage[j] << ", ";
786 }
787 }
788 }
789 if(DEBUG || kVerbose > 0) G4cout << G4endl;
790 delete [] dimage;
791
792 // relative location of the dose distribution image for
793 // the modality image
794 getDoseDistCenterPosition(fCenter, ndose);
795 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
796 if(kLittleEndianOutput) {
797 ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
798 } else {
799 for(int j = 0; j < 3; j++)
800 invertByteOrder((char *)&iCenter[j], itmp[j]);
801 ofile.write((char *)itmp, 12);
802 }
803 if(DEBUG || kVerbose > 0) {
804 G4cout << "Dose dist. [" << ndose
805 << "]image relative location : ("
806 << iCenter[0] << ", "
807 << iCenter[1] << ", "
808 << iCenter[2] << ")" << G4endl;
809 }
810
811 // dose distribution name
812 std::string name = getDoseDistName(ndose);
813 if(name.size() == 0) name = "dose";
814 name.resize(80);
815 ofile.write((char *)name.c_str(), 80);
816 if(DEBUG || kVerbose > 0) {
817 G4cout << "Dose dist. name : " << name << G4endl;
818 }
819
820 }
821 }
822
823 //----- ROI image -----//
824 if(!isROIEmpty()) {
825 // ROI image size
826 kRoi[0].getSize(size);
827 if(kLittleEndianOutput) {
828 ofile.write((char *)size, 3*sizeof(int));
829 } else {
830 for(int j = 0; j < 3; j++)
831 invertByteOrder((char *)&size[j], itmp[j]);
832 ofile.write((char *)itmp, 12);
833 }
834 if(DEBUG || kVerbose > 0) {
835 G4cout << "ROI image size : ("
836 << size[0] << ", "
837 << size[1] << ", "
838 << size[2] << ")"
839 << G4endl;
840 }
841
842 // ROI max. & min.
843 kRoi[0].getMinMax(minmax);
844 if(kLittleEndianOutput) {
845 ofile.write((char *)minmax, sizeof(short)*2);
846 } else {
847 for(int j = 0; j < 2; j++)
848 invertByteOrder((char *)&minmax[j], stmp[j]);
849 ofile.write((char *)stmp, 4);
850 }
851
852 // ROI distribution scaling
853 scale = (float)kRoi[0].getScale();
854 if(kLittleEndianOutput) {
855 ofile.write((char *)&scale, sizeof(float));
856 } else {
857 invertByteOrder((char *)&scale, ftmp[0]);
858 ofile.write((char *)ftmp, 4);
859 }
860 if(DEBUG || kVerbose > 0) {
861 G4cout << "ROI image min., max., scale : "
862 << minmax[0] << ", "
863 << minmax[1] << ", "
864 << scale << G4endl;
865 }
866
867 // ROI image
868 int rsize = size[0]*size[1];
869 for(int i = 0; i < size[2]; i++) {
870 short * rimage = kRoi[0].getImage(i);
871 if(kLittleEndianOutput) {
872 ofile.write((char *)rimage, rsize*sizeof(short));
873 } else {
874 for(int j = 0; j < rsize; j++) {
875 invertByteOrder((char *)&rimage[j], stmp[0]);
876 ofile.write((char *)stmp, 2);
877 }
878 }
879
880 }
881
882 // ROI relative location
883 kRoi[0].getCenterPosition(fCenter);
884 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
885 if(kLittleEndianOutput) {
886 ofile.write((char *)iCenter, 3*sizeof(int));
887 } else {
888 for(int j = 0; j < 3; j++)
889 invertByteOrder((char *)&iCenter[j], itmp[j]);
890 ofile.write((char *)itmp, 12);
891 }
892 if(DEBUG || kVerbose > 0) {
893 G4cout << "ROI image relative location : ("
894 << iCenter[0] << ", "
895 << iCenter[1] << ", "
896 << iCenter[2] << ")" << G4endl;
897 }
898 }
899
900 //----- track information -----//
901 // number of track
902 if(kPointerToTrackData > 0) {
903
904 int ntrk = kTracks.size();
905 if(kLittleEndianOutput) {
906 ofile.write((char *)&ntrk, sizeof(int));
907 } else {
908 invertByteOrder((char *)&ntrk, itmp[0]);
909 ofile.write((char *)itmp, 4);
910 }
911 if(DEBUG || kVerbose > 0) {
912 G4cout << "# of tracks : "
913 << ntrk << G4endl;
914 }
915
916 for(int nt = 0; nt < ntrk; nt++) {
917
918 // # of steps in a track
919 int nsteps = kTracks[nt].getNumberOfSteps();
920 if(kLittleEndianOutput) {
921 ofile.write((char *)&nsteps, sizeof(int));
922 } else {
923 invertByteOrder((char *)&nsteps, itmp[0]);
924 ofile.write((char *)itmp, 4);
925 }
926 if(DEBUG || kVerbose > 0) {
927 G4cout << "# of steps : " << nsteps << G4endl;
928 }
929
930 // track color
931 unsigned char tcolor[3];
932 kTracks[nt].getColor(tcolor);
933 ofile.write((char *)tcolor, 3);
934
935 // steps
936 float stepPoints[6];
937 for(int isteps = 0; isteps < nsteps; isteps++) {
938 kTracks[nt].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
939 stepPoints[3], stepPoints[4], stepPoints[5],
940 isteps);
941
942 if(kLittleEndianOutput) {
943 ofile.write((char *)stepPoints, sizeof(float)*6);
944 } else {
945 for(int j = 0; j < 6; j++)
946 invertByteOrder((char *)&stepPoints[j], ftmp[j]);
947 ofile.write((char *)ftmp, 24);
948 }
949 }
950 }
951 }
952
953 //----- detector information -----//
954 // number of detectors
955 if(kPointerToDetectorData > 0) {
956 int ndet = kDetectors.size();
957 if(kLittleEndianOutput) {
958 ofile.write((char *)&ndet, sizeof(int));
959 } else {
960 invertByteOrder((char *)&ndet, itmp[0]);
961 ofile.write((char *)itmp, 4);
962 }
963 if(DEBUG || kVerbose > 0) {
964 G4cout << "# of detectors : "
965 << ndet << G4endl;
966 }
967
968 for(int nd = 0; nd < ndet; nd++) {
969
970 // # of edges of a detector
971 int nedges = kDetectors[nd].getNumberOfEdges();
972 if(kLittleEndianOutput) {
973 ofile.write((char *)&nedges, sizeof(int));
974 } else {
975 invertByteOrder((char *)&nedges, itmp[0]);
976 ofile.write((char *)itmp, 4);
977 }
978 if(DEBUG || kVerbose > 0) {
979 G4cout << "# of edges in a detector : " << nedges << G4endl;
980 }
981
982 // edges
983 float edgePoints[6];
984 for(int ne = 0; ne < nedges; ne++) {
985 kDetectors[nd].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
986 edgePoints[3], edgePoints[4], edgePoints[5],
987 ne);
988
989 if(kLittleEndianOutput) {
990 ofile.write((char *)edgePoints, sizeof(float)*6);
991 } else {
992 for(int j = 0; j < 6; j++)
993 invertByteOrder((char *)&edgePoints[j], ftmp[j]);
994 ofile.write((char *)ftmp, 24);
995 }
996
997 if(DEBUG || kVerbose > 0) {
998 if(ne < 1) {
999 G4cout << " edge : (" << edgePoints[0] << ", "
1000 << edgePoints[1] << ", "
1001 << edgePoints[2] << ") - ("
1002 << edgePoints[3] << ", "
1003 << edgePoints[4] << ", "
1004 << edgePoints[5] << ")" << G4endl;
1005 }
1006 }
1007 }
1008
1009 // detector color
1010 unsigned char dcolor[3];
1011 kDetectors[nd].getColor(dcolor);
1012 ofile.write((char *)dcolor, 3);
1013 if(DEBUG || kVerbose > 0) {
1014 G4cout << " rgb : (" << (int)dcolor[0] << ", "
1015 << (int)dcolor[1] << ", "
1016 << (int)dcolor[2] << ")" << G4endl;
1017 }
1018
1019 // detector name
1020 std::string dname = kDetectors[nd].getName();
1021 dname.resize(80);
1022 ofile.write((char *)dname.c_str(), 80);
1023 if(DEBUG || kVerbose > 0) {
1024 G4cout << " detector name : " << dname << G4endl;
1025
1026 }
1027 }
1028 }
1029
1030 // file end mark
1031 ofile.write("END", 3);
1032
1033 ofile.close();
1034 if(DEBUG || kVerbose > 0)
1035 G4cout << ">>>> closed gdd file: " << kFileName << G4endl;
1036
1037 return true;
1038}
1039bool G4GMocrenIO::storeData3() {
1040
1041 if(kVerbose > 0) G4cout << ">>>>>>> store data (ver.3) <<<<<<<" << G4endl;
1042 if(kVerbose > 0) G4cout << " " << kFileName << G4endl;
1043
1044 bool DEBUG = false;//
1045
1046 // output file open
1047 std::ofstream ofile(kFileName.c_str(),
1048 std::ios_base::out|std::ios_base::binary);
1049
1050 // file identifier
1051 ofile.write("gMocren ", 8);
1052
1053 // file version
1054 unsigned char ver = 0x03;
1055 ofile.write((char *)&ver, 1);
1056
1057 // endian
1058 ofile.write((char *)&kLittleEndianOutput, sizeof(char));
1059
1060 // comment length (fixed size)
1061 int commentLength = 1024;
1062 ofile.write((char *)&commentLength, 4);
1063
1064 // comment
1065 char cmt[1025];
1066 std::strncpy(cmt, kComment.c_str(), 1024);
1067 ofile.write((char *)cmt, 1024);
1068 if(DEBUG || kVerbose > 0) {
1069 G4cout << "Data comment : "
1070 << kComment << G4endl;
1071 }
1072
1073 // voxel spacings for all images
1074 ofile.write((char *)kVoxelSpacing, 12);
1075 if(DEBUG || kVerbose > 0) {
1076 G4cout << "Voxel spacing : ("
1077 << kVoxelSpacing[0] << ", "
1078 << kVoxelSpacing[1] << ", "
1079 << kVoxelSpacing[2]
1080 << ") mm " << G4endl;
1081 }
1082
1083 calcPointers3();
1084
1085 // offset from file starting point to the modality image data
1086 ofile.write((char *)&kPointerToModalityData, 4);
1087
1088 // # of dose distributions
1089 //int nDoseDist = (int)pointerToDoseDistData.size();
1090 int nDoseDist = getNumDoseDist();
1091 ofile.write((char *)&nDoseDist, 4);
1092
1093 // offset from file starting point to the dose image data
1094 for(int i = 0; i < nDoseDist; i++) {
1095 ofile.write((char *)&kPointerToDoseDistData[i], 4);
1096 }
1097
1098 // offset from file starting point to the ROI image data
1099 ofile.write((char *)&kPointerToROIData, 4);
1100
1101 // offset from file starting point to the track data
1102 ofile.write((char *)&kPointerToTrackData, 4);
1103 if(DEBUG || kVerbose > 0) {
1104 G4cout << "Each pointer to data : "
1105 << kPointerToModalityData << ", ";
1106 for(int i = 0; i < nDoseDist; i++) {
1107 G4cout << kPointerToDoseDistData[i] << ", ";
1108 }
1109 G4cout << kPointerToROIData << ", "
1110 << kPointerToTrackData << G4endl;
1111 }
1112
1113 //----- modality image -----//
1114
1115 int size[3];
1116 float scale;
1117 short minmax[2];
1118 float fCenter[3];
1119 int iCenter[3];
1120 // modality image size
1121 kModality.getSize(size);
1122 ofile.write((char *)size, 3*sizeof(int));
1123 if(DEBUG || kVerbose > 0) {
1124 G4cout << "Modality image size : ("
1125 << size[0] << ", "
1126 << size[1] << ", "
1127 << size[2] << ")"
1128 << G4endl;
1129 }
1130
1131 // modality image max. & min.
1132 kModality.getMinMax(minmax);
1133 ofile.write((char *)minmax, 4);
1134
1135 // modality image unit
1136 char munit[13] = "g/cm3 ";
1137 ofile.write((char *)munit, 12);
1138
1139 // modality image scale
1140 scale = (float)kModality.getScale();
1141 ofile.write((char *)&scale, 4);
1142 if(DEBUG || kVerbose > 0) {
1143 G4cout << "Modality image min., max., scale : "
1144 << minmax[0] << ", "
1145 << minmax[1] << ", "
1146 << scale << G4endl;
1147 }
1148
1149 // modality image
1150 int psize = size[0]*size[1];
1151 if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
1152 for(int i = 0; i < size[2]; i++) {
1153 short * image = kModality.getImage(i);
1154 ofile.write((char *)image, psize*sizeof(short));
1155
1156 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
1157 }
1158 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1159
1160 // modality desity map for CT value
1161 size_t msize = minmax[1] - minmax[0]+1;
1162 float * pdmap = new float[msize];
1163 for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i];
1164 ofile.write((char *)pdmap, msize*sizeof(float));
1165 if(DEBUG || kVerbose > 0) {
1166 G4cout << "density map : " << std::ends;
1167 for(int i = 0; i < (int)msize; i+=50)
1168 G4cout <<kModalityImageDensityMap[i] << ", ";
1169 G4cout << G4endl;
1170 }
1171 delete [] pdmap;
1172
1173
1174 //----- dose distribution image -----//
1175
1176 if(!isDoseEmpty()) {
1177
1178 calcDoseDistScale();
1179
1180 for(int ndose = 0; ndose < nDoseDist; ndose++) {
1181 // dose distrbution image size
1182 kDose[ndose].getSize(size);
1183 ofile.write((char *)size, 3*sizeof(int));
1184 if(DEBUG || kVerbose > 0) {
1185 G4cout << "Dose dist. [" << ndose << "] image size : ("
1186 << size[0] << ", "
1187 << size[1] << ", "
1188 << size[2] << ")"
1189 << G4endl;
1190 }
1191
1192 // dose distribution max. & min.
1193 getShortDoseDistMinMax(minmax, ndose);
1194 ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
1195
1196 // dose distribution unit
1197 ofile.write((char *)kDoseUnit.c_str(), 12);
1198 if(DEBUG || kVerbose > 0) {
1199 G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
1200 }
1201
1202 // dose distribution scaling
1203 double dscale;
1204 dscale = getDoseDistScale(ndose);
1205 scale = float(dscale);
1206 ofile.write((char *)&scale, 4);
1207 if(DEBUG || kVerbose > 0) {
1208 G4cout << "Dose dist. [" << ndose
1209 << "] image min., max., scale : "
1210 << minmax[0] << ", "
1211 << minmax[1] << ", "
1212 << scale << G4endl;
1213 }
1214
1215 // dose distribution image
1216 int dsize = size[0]*size[1];
1217 short * dimage = new short[dsize];
1218 for(int z = 0; z < size[2]; z++) {
1219 getShortDoseDist(dimage, z, ndose);
1220 ofile.write((char *)dimage, dsize*2); //sizeof(short)
1221
1222 if(DEBUG || kVerbose > 0) {
1223 for(int j = 0; j < dsize; j++) {
1224 if(dimage[j] < 0)
1225 G4cout << "[" << j << "," << z << "]"
1226 << dimage[j] << ", ";
1227 }
1228 }
1229 }
1230 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1231 delete [] dimage;
1232
1233 // relative location of the dose distribution image for
1234 // the modality image
1235 getDoseDistCenterPosition(fCenter, ndose);
1236 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1237 ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
1238 if(DEBUG || kVerbose > 0) {
1239 G4cout << "Dose dist. [" << ndose
1240 << "]image relative location : ("
1241 << iCenter[0] << ", "
1242 << iCenter[1] << ", "
1243 << iCenter[2] << ")" << G4endl;
1244 }
1245 }
1246 }
1247
1248 //----- ROI image -----//
1249 if(!isROIEmpty()) {
1250 // ROI image size
1251 kRoi[0].getSize(size);
1252 ofile.write((char *)size, 3*sizeof(int));
1253 if(DEBUG || kVerbose > 0) {
1254 G4cout << "ROI image size : ("
1255 << size[0] << ", "
1256 << size[1] << ", "
1257 << size[2] << ")"
1258 << G4endl;
1259 }
1260
1261 // ROI max. & min.
1262 kRoi[0].getMinMax(minmax);
1263 ofile.write((char *)minmax, sizeof(short)*2);
1264
1265 // ROI distribution scaling
1266 scale = (float)kRoi[0].getScale();
1267 ofile.write((char *)&scale, sizeof(float));
1268 if(DEBUG || kVerbose > 0) {
1269 G4cout << "ROI image min., max., scale : "
1270 << minmax[0] << ", "
1271 << minmax[1] << ", "
1272 << scale << G4endl;
1273 }
1274
1275 // ROI image
1276 int rsize = size[0]*size[1];
1277 for(int i = 0; i < size[2]; i++) {
1278 short * rimage = kRoi[0].getImage(i);
1279 ofile.write((char *)rimage, rsize*sizeof(short));
1280
1281 }
1282
1283 // ROI relative location
1284 kRoi[0].getCenterPosition(fCenter);
1285 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1286 ofile.write((char *)iCenter, 3*sizeof(int));
1287 if(DEBUG || kVerbose > 0) {
1288 G4cout << "ROI image relative location : ("
1289 << iCenter[0] << ", "
1290 << iCenter[1] << ", "
1291 << iCenter[2] << ")" << G4endl;
1292 }
1293 }
1294
1295 //----- track information -----//
1296 // number of track
1297 int ntrk = kSteps.size();
1298 ofile.write((char *)&ntrk, sizeof(int));
1299 if(DEBUG || kVerbose > 0) {
1300 G4cout << "# of tracks : "
1301 << ntrk << G4endl;
1302 }
1303 // track position
1304 for(int i = 0; i < ntrk; i++) {
1305 float * tp = kSteps[i];
1306 ofile.write((char *)tp, sizeof(float)*6);
1307 }
1308 // track color
1309 int ntcolor = int(kStepColors.size());
1310 if(ntrk != ntcolor)
1311 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1312 G4cout << "# of track color information must be the same as # of tracks."
1313 << G4endl;
1314 unsigned char white[3] = {255,255,255}; // default color
1315 for(int i = 0; i < ntrk; i++) {
1316 if(i < ntcolor) {
1317 unsigned char * tcolor = kStepColors[i];
1318 ofile.write((char *)tcolor, 3);
1319 } else {
1320 ofile.write((char *)white, 3);
1321 }
1322 }
1323
1324 // file end mark
1325 ofile.write("END", 3);
1326
1327 ofile.close();
1328
1329 return true;
1330}
1331//
1332bool G4GMocrenIO::storeData4(char * _filename) {
1333 kFileName = _filename;
1334 return storeData4();
1335}
1336
1337// version 2
1338bool G4GMocrenIO::storeData2() {
1339
1340 if(kVerbose > 0) G4cout << ">>>>>>> store data (ver.2) <<<<<<<" << G4endl;
1341 if(kVerbose > 0) G4cout << " " << kFileName << G4endl;
1342
1343 bool DEBUG = false;//
1344
1345 // output file open
1346 std::ofstream ofile(kFileName.c_str(),
1347 std::ios_base::out|std::ios_base::binary);
1348
1349 // file identifier
1350 ofile.write("GRAPE ", 8);
1351
1352 // file version
1353 unsigned char ver = 0x02;
1354 ofile.write((char *)&ver, 1);
1355 // file id for old file format support
1356 ofile.write(kId.c_str(), IDLENGTH);
1357 // file version for old file format support
1358 ofile.write(kVersion.c_str(), VERLENGTH);
1359 // endian
1360 ofile.write((char *)&kLittleEndianOutput, sizeof(char));
1361
1362 /*
1363 // event number
1364 ofile.write((char *)&numberOfEvents, sizeof(int));
1365 float imageSpacing[3];
1366 imageSpacing[0] = modalityImageVoxelSpacing[0];
1367 imageSpacing[1] = modalityImageVoxelSpacing[1];
1368 imageSpacing[2] = modalityImageVoxelSpacing[2];
1369 ofile.write((char *)imageSpacing, 12);
1370 */
1371
1372
1373 // voxel spacings for all images
1374 ofile.write((char *)kVoxelSpacing, 12);
1375 if(DEBUG || kVerbose > 0) {
1376 G4cout << "Voxel spacing : ("
1377 << kVoxelSpacing[0] << ", "
1378 << kVoxelSpacing[1] << ", "
1379 << kVoxelSpacing[2]
1380 << ") mm " << G4endl;
1381 }
1382
1383 calcPointers2();
1384 // offset from file starting point to the modality image data
1385 ofile.write((char *)&kPointerToModalityData, 4);
1386
1387 // offset from file starting point to the dose image data
1388 ofile.write((char *)&kPointerToDoseDistData[0], 4);
1389
1390 // offset from file starting point to the ROI image data
1391 ofile.write((char *)&kPointerToROIData, 4);
1392
1393 // offset from file starting point to the track data
1394 ofile.write((char *)&kPointerToTrackData, 4);
1395 if(DEBUG || kVerbose > 0) {
1396 G4cout << "Each pointer to data : "
1397 << kPointerToModalityData << ", "
1398 << kPointerToDoseDistData[0] << ", "
1399 << kPointerToROIData << ", "
1400 << kPointerToTrackData << G4endl;
1401 }
1402
1403 //----- modality image -----//
1404
1405 int size[3];
1406 float scale;
1407 short minmax[2];
1408 float fCenter[3];
1409 int iCenter[3];
1410 // modality image size
1411 kModality.getSize(size);
1412 ofile.write((char *)size, 3*sizeof(int));
1413 if(DEBUG || kVerbose > 0) {
1414 G4cout << "Modality image size : ("
1415 << size[0] << ", "
1416 << size[1] << ", "
1417 << size[2] << ")"
1418 << G4endl;
1419 }
1420
1421 // modality image max. & min.
1422 kModality.getMinMax(minmax);
1423 ofile.write((char *)minmax, 4);
1424
1425 // modality image unit
1426 //char munit[13] = "g/cm3 ";
1427 //ofile.write((char *)&munit, 12);
1428
1429 // modality image scale
1430 scale = (float)kModality.getScale();
1431 ofile.write((char *)&scale, 4);
1432 if(DEBUG || kVerbose > 0) {
1433 G4cout << "Modality image min., max., scale : "
1434 << minmax[0] << ", "
1435 << minmax[1] << ", "
1436 << scale << G4endl;
1437 }
1438
1439 // modality image
1440 int psize = size[0]*size[1];
1441 if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
1442 for(int i = 0; i < size[2]; i++) {
1443 short * image =kModality.getImage(i);
1444 ofile.write((char *)image, psize*sizeof(short));
1445
1446 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
1447 }
1448 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1449
1450 // modality desity map for CT value
1451 size_t msize = minmax[1] - minmax[0]+1;
1452 float * pdmap = new float[msize];
1453 for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i];
1454 ofile.write((char *)pdmap, msize*sizeof(float));
1455 if(DEBUG || kVerbose > 0) {
1456 G4cout << "density map : " << std::ends;
1457 for(int i = 0; i < (int)msize; i+=50)
1458 G4cout <<kModalityImageDensityMap[i] << ", ";
1459 G4cout << G4endl;
1460 }
1461 delete [] pdmap;
1462
1463
1464 //----- dose distribution image -----//
1465
1466 if(!isDoseEmpty()) {
1467 calcDoseDistScale();
1468
1469 // dose distrbution image size
1470 kDose[0].getSize(size);
1471 ofile.write((char *)size, 3*sizeof(int));
1472 if(DEBUG || kVerbose > 0) {
1473 G4cout << "Dose dist. image size : ("
1474 << size[0] << ", "
1475 << size[1] << ", "
1476 << size[2] << ")"
1477 << G4endl;
1478 }
1479
1480 // dose distribution max. & min.
1481 getShortDoseDistMinMax(minmax);
1482 ofile.write((char *)minmax, sizeof(short)*2);
1483
1484 // dose distribution scaling
1485 scale = (float)kDose[0].getScale();
1486 ofile.write((char *)&scale, sizeof(float));
1487 if(DEBUG || kVerbose > 0) {
1488 G4cout << "Dose dist. image min., max., scale : "
1489 << minmax[0] << ", "
1490 << minmax[1] << ", "
1491 << scale << G4endl;
1492 }
1493
1494 // dose distribution image
1495 int dsize = size[0]*size[1];
1496 short * dimage = new short[dsize];
1497 for(int z = 0; z < size[2]; z++) {
1498 getShortDoseDist(dimage, z);
1499 ofile.write((char *)dimage, dsize*sizeof(short));
1500
1501 if(DEBUG || kVerbose > 0) {
1502 for(int j = 0; j < dsize; j++) {
1503 if(dimage[j] < 0)
1504 G4cout << "[" << j << "," << z << "]"
1505 << dimage[j] << ", ";
1506 }
1507 }
1508 }
1509 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1510 delete [] dimage;
1511
1512 // relative location of the dose distribution image for
1513 // the modality image
1514 kDose[0].getCenterPosition(fCenter);
1515 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1516 ofile.write((char *)iCenter, 3*sizeof(int));
1517 if(DEBUG || kVerbose > 0) {
1518 G4cout << "Dose dist. image relative location : ("
1519 << iCenter[0] << ", "
1520 << iCenter[1] << ", "
1521 << iCenter[2] << ")" << G4endl;
1522 }
1523
1524 }
1525
1526 //----- ROI image -----//
1527 if(!isROIEmpty()) {
1528 // ROI image size
1529 kRoi[0].getSize(size);
1530 ofile.write((char *)size, 3*sizeof(int));
1531 if(DEBUG || kVerbose > 0) {
1532 G4cout << "ROI image size : ("
1533 << size[0] << ", "
1534 << size[1] << ", "
1535 << size[2] << ")"
1536 << G4endl;
1537 }
1538
1539 // ROI max. & min.
1540 kRoi[0].getMinMax(minmax);
1541 ofile.write((char *)minmax, sizeof(short)*2);
1542
1543 // ROI distribution scaling
1544 scale = (float)kRoi[0].getScale();
1545 ofile.write((char *)&scale, sizeof(float));
1546 if(DEBUG || kVerbose > 0) {
1547 G4cout << "ROI image min., max., scale : "
1548 << minmax[0] << ", "
1549 << minmax[1] << ", "
1550 << scale << G4endl;
1551 }
1552
1553 // ROI image
1554 int rsize = size[0]*size[1];
1555 for(int i = 0; i < size[2]; i++) {
1556 short * rimage = kRoi[0].getImage(i);
1557 ofile.write((char *)rimage, rsize*sizeof(short));
1558
1559 }
1560
1561 // ROI relative location
1562 kRoi[0].getCenterPosition(fCenter);
1563 for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1564 ofile.write((char *)iCenter, 3*sizeof(int));
1565 if(DEBUG || kVerbose > 0) {
1566 G4cout << "ROI image relative location : ("
1567 << iCenter[0] << ", "
1568 << iCenter[1] << ", "
1569 << iCenter[2] << ")" << G4endl;
1570 }
1571 }
1572
1573
1574 //----- track information -----//
1575 // track
1576 int ntrk = kSteps.size();
1577 ofile.write((char *)&ntrk, sizeof(int));
1578 if(DEBUG || kVerbose > 0) {
1579 G4cout << "# of tracks : "
1580 << ntrk << G4endl;
1581 }
1582 for(int i = 0; i < ntrk; i++) {
1583 float * tp = kSteps[i];
1584 ofile.write((char *)tp, sizeof(float)*6);
1585 }
1586
1587
1588 // file end mark
1589 ofile.write("END", 3);
1590
1591 ofile.close();
1592
1593 return true;
1594}
1595//
1596bool G4GMocrenIO::storeData2(char * _filename) {
1597 kFileName = _filename;
1598 return storeData();
1599}
1600
1601bool G4GMocrenIO::retrieveData() {
1602
1603 // input file open
1604 std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
1605 if(!ifile) {
1606 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1607 G4cout << "Cannot open file: " << kFileName
1608 << " in G4GMocrenIO::retrieveData()." << G4endl;
1609 return false;
1610 }
1611
1612 // file identifier
1613 char verid[9];
1614 ifile.read((char *)verid, 8);
1615 // file version
1616 unsigned char ver;
1617 ifile.read((char *)&ver, 1);
1618 ifile.close();
1619
1620 if(std::strncmp(verid, "gMocren", 7) == 0) {
1621 if(ver == 0x03) {
1622 G4cout << ">>>>>>> retrieve data (ver.3) <<<<<<<" << G4endl;
1623 G4cout << " " << kFileName << G4endl;
1624 retrieveData3();
1625 } else if (ver == 0x04) {
1626 G4cout << ">>>>>>> retrieve data (ver.4) <<<<<<<" << G4endl;
1627 G4cout << " " << kFileName << G4endl;
1628 retrieveData4();
1629 } else {
1630 if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
1631 G4cout << "Error -- invalid file version : " << (int)ver
1632 << G4endl;
1633 G4cout << " " << kFileName << G4endl;
1634 }
1635 std::exit(-1);
1636 }
1637 } else if(std::strncmp(verid, "GRAPE", 5) == 0) {
1638 G4cout << ">>>>>>> retrieve data (ver.2) <<<<<<<" << G4endl;
1639 G4cout << " " << kFileName << G4endl;
1640 retrieveData2();
1641 } else {
1642 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1643 G4cout << kFileName << " was not gdd file." << G4endl;
1644 return false;
1645 }
1646
1647 return true;
1648}
1649
1650bool G4GMocrenIO::retrieveData(char * _filename) {
1651 kFileName = _filename;
1652 return retrieveData();
1653}
1654
1655//
1656bool G4GMocrenIO::retrieveData4() {
1657
1658 bool DEBUG = false;//
1659
1660 // input file open
1661 std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
1662 if(!ifile) {
1663 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1664 G4cout << "Cannot open file: " << kFileName
1665 << " in G4GMocrenIO::retrieveData3()." << G4endl;
1666 return false;
1667 }
1668
1669 // data buffer
1670 char ctmp[24];
1671
1672 // file identifier
1673 char verid[9];
1674 ifile.read((char *)verid, 8);
1675
1676 // file version
1677 unsigned char ver;
1678 ifile.read((char *)&ver, 1);
1679 std::stringstream ss;
1680 ss << (int)ver;
1681 kVersion = ss.str();
1682 if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
1683
1684 // endian
1685 ifile.read((char *)&kLittleEndianInput, sizeof(char));
1686 if(DEBUG || kVerbose > 0) {
1687 G4cout << "Endian : ";
1688 if(kLittleEndianInput == 1)
1689 G4cout << " little" << G4endl;
1690 else {
1691 G4cout << " big" << G4endl;
1692 }
1693 }
1694
1695 // comment length (fixed size)
1696 int clength;
1697 ifile.read((char *)ctmp, 4);
1698 convertEndian(ctmp, clength);
1699 // comment
1700 char cmt[1025];
1701 ifile.read((char *)cmt, clength);
1702 std::string scmt = cmt;
1703 scmt += '\0';
1704 setComment(scmt);
1705 if(DEBUG || kVerbose > 0) {
1706 G4cout << "Data comment : "
1707 << kComment << G4endl;
1708 }
1709
1710 // voxel spacings for all images
1711 ifile.read((char *)ctmp, 12);
1712 convertEndian(ctmp, kVoxelSpacing[0]);
1713 convertEndian(ctmp+4, kVoxelSpacing[1]);
1714 convertEndian(ctmp+8, kVoxelSpacing[2]);
1715 if(DEBUG || kVerbose > 0) {
1716 G4cout << "Voxel spacing : ("
1717 << kVoxelSpacing[0] << ", "
1718 << kVoxelSpacing[1] << ", "
1719 << kVoxelSpacing[2]
1720 << ") mm " << G4endl;
1721 }
1722
1723
1724 // offset from file starting point to the modality image data
1725 ifile.read((char *)ctmp, 4);
1726 convertEndian(ctmp, kPointerToModalityData);
1727
1728 // # of dose distributions
1729 ifile.read((char *)ctmp, 4);
1730 int nDoseDist;
1731 convertEndian(ctmp, nDoseDist);
1732
1733 // offset from file starting point to the dose image data
1734 for(int i = 0; i < nDoseDist; i++) {
1735 ifile.read((char *)ctmp, 4);
1736 unsigned int dptr;
1737 convertEndian(ctmp, dptr);
1738 addPointerToDoseDistData(dptr);
1739 }
1740
1741 // offset from file starting point to the ROI image data
1742 ifile.read((char *)ctmp, 4);
1743 convertEndian(ctmp, kPointerToROIData);
1744
1745 // offset from file starting point to the track data
1746 ifile.read((char *)ctmp, 4);
1747 convertEndian(ctmp, kPointerToTrackData);
1748
1749 // offset from file starting point to the detector data
1750 ifile.read((char *)ctmp, 4);
1751 convertEndian(ctmp, kPointerToDetectorData);
1752
1753 if(DEBUG || kVerbose > 0) {
1754 G4cout << "Each pointer to data : "
1755 << kPointerToModalityData << ", ";
1756 for(int i = 0; i < nDoseDist; i++)
1757 G4cout << kPointerToDoseDistData[i] << ", ";
1758 G4cout << kPointerToROIData << ", "
1759 << kPointerToTrackData << ", "
1760 << kPointerToDetectorData
1761 << G4endl;
1762 }
1763
1764
1765
1766 if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
1767 kPointerToROIData == 0 && kPointerToTrackData == 0) {
1768 if(DEBUG || kVerbose > 0) {
1769 G4cout << "No data." << G4endl;
1770 }
1771 return false;
1772 }
1773
1774 // event number
1775 /* ver 1
1776 ifile.read(ctmp, sizeof(int));
1777 convertEndian(ctmp, numberOfEvents);
1778 */
1779
1780 int size[3];
1781 float scale;
1782 double dscale;
1783 short minmax[2];
1784 float fCenter[3];
1785 int iCenter[3];
1786
1787 //----- Modality image -----//
1788 // modality image size
1789 ifile.read(ctmp, 3*sizeof(int));
1790 convertEndian(ctmp, size[0]);
1791 convertEndian(ctmp+sizeof(int), size[1]);
1792 convertEndian(ctmp+2*sizeof(int), size[2]);
1793 if(DEBUG || kVerbose > 0) {
1794 G4cout << "Modality image size : ("
1795 << size[0] << ", "
1796 << size[1] << ", "
1797 << size[2] << ")"
1798 << G4endl;
1799 }
1800 kModality.setSize(size);
1801
1802 // modality image voxel spacing
1803 /*
1804 ifile.read(ctmp, 3*sizeof(float));
1805 convertEndian(ctmp, modalityImageVoxelSpacing[0]);
1806 convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
1807 convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
1808 */
1809
1810 if(kPointerToModalityData != 0) {
1811
1812 // modality density max. & min.
1813 ifile.read((char *)ctmp, 4);
1814 convertEndian(ctmp, minmax[0]);
1815 convertEndian(ctmp+2, minmax[1]);
1816 kModality.setMinMax(minmax);
1817
1818 // modality image unit
1819 char munit[13];
1820 munit[12] = '\0';
1821 ifile.read((char *)munit, 12);
1822 std::string smunit = munit;
1823 setModalityImageUnit(smunit);
1824
1825 // modality density scale
1826 ifile.read((char *)ctmp, 4);
1827 convertEndian(ctmp, scale);
1828 kModality.setScale(dscale = scale);
1829 if(DEBUG || kVerbose > 0) {
1830 G4cout << "Modality image min., max., scale : "
1831 << minmax[0] << ", "
1832 << minmax[1] << ", "
1833 << scale << G4endl;
1834 }
1835
1836 // modality density
1837 int psize = size[0]*size[1];
1838 if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
1839 char * cimage = new char[psize*sizeof(short)];
1840 for(int i = 0; i < size[2]; i++) {
1841 ifile.read((char *)cimage, psize*sizeof(short));
1842 short * mimage = new short[psize];
1843 for(int j = 0; j < psize; j++) {
1844 convertEndian(cimage+j*sizeof(short), mimage[j]);
1845 }
1846 kModality.addImage(mimage);
1847
1848 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
1849 }
1850 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1851 delete [] cimage;
1852
1853 // modality desity map for CT value
1854 size_t msize = minmax[1]-minmax[0]+1;
1855 if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
1856 char * pdmap = new char[msize*sizeof(float)];
1857 ifile.read((char *)pdmap, msize*sizeof(float));
1858 float ftmp;
1859 for(int i = 0; i < (int)msize; i++) {
1860 convertEndian(pdmap+i*sizeof(float), ftmp);
1861 kModalityImageDensityMap.push_back(ftmp);
1862 }
1863 delete [] pdmap;
1864
1865 if(DEBUG || kVerbose > 0) {
1866 G4cout << "density map : " << std::ends;
1867 for(int i = 0; i < 10; i++)
1868 G4cout <<kModalityImageDensityMap[i] << ", ";
1869 G4cout << G4endl;
1870 for(int i = 0; i < 10; i++) G4cout << "..";
1871 G4cout << G4endl;
1872 for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
1873 G4cout <<kModalityImageDensityMap[i] << ", ";
1874 G4cout << G4endl;
1875 }
1876
1877 }
1878
1879
1880 //----- dose distribution image -----//
1881 for(int ndose = 0; ndose < nDoseDist; ndose++) {
1882
1883 newDoseDist();
1884
1885 // dose distrbution image size
1886 ifile.read((char *)ctmp, 3*sizeof(int));
1887 convertEndian(ctmp, size[0]);
1888 convertEndian(ctmp+sizeof(int), size[1]);
1889 convertEndian(ctmp+2*sizeof(int), size[2]);
1890 if(DEBUG || kVerbose > 0) {
1891 G4cout << "Dose dist. image size : ("
1892 << size[0] << ", "
1893 << size[1] << ", "
1894 << size[2] << ")"
1895 << G4endl;
1896 }
1897 kDose[ndose].setSize(size);
1898
1899 // dose distribution max. & min.
1900 ifile.read((char *)ctmp, sizeof(short)*2);
1901 convertEndian(ctmp, minmax[0]);
1902 convertEndian(ctmp+2, minmax[1]);
1903
1904 // dose distribution unit
1905 char dunit[13];
1906 dunit[12] = '\0';
1907 ifile.read((char *)dunit, 12);
1908 std::string sdunit = dunit;
1909 setDoseDistUnit(sdunit, ndose);
1910 if(DEBUG || kVerbose > 0) {
1911 G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
1912 }
1913
1914 // dose distribution scaling
1915 ifile.read((char *)ctmp, 4); // sizeof(float)
1916 convertEndian(ctmp, scale);
1917 kDose[ndose].setScale(dscale = scale);
1918
1919 double dminmax[2];
1920 for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
1921 kDose[ndose].setMinMax(dminmax);
1922
1923 if(DEBUG || kVerbose > 0) {
1924 G4cout << "Dose dist. image min., max., scale : "
1925 << dminmax[0] << ", "
1926 << dminmax[1] << ", "
1927 << scale << G4endl;
1928 }
1929
1930 // dose distribution image
1931 int dsize = size[0]*size[1];
1932 if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
1933 char * di = new char[dsize*sizeof(short)];
1934 short * shimage = new short[dsize];
1935 for(int z = 0; z < size[2]; z++) {
1936 ifile.read((char *)di, dsize*sizeof(short));
1937 double * dimage = new double[dsize];
1938 for(int xy = 0; xy < dsize; xy++) {
1939 convertEndian(di+xy*sizeof(short), shimage[xy]);
1940 dimage[xy] = shimage[xy]*dscale;
1941 }
1942 kDose[ndose].addImage(dimage);
1943
1944 if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
1945
1946 if(DEBUG || kVerbose > 0) {
1947 for(int j = 0; j < dsize; j++) {
1948 if(dimage[j] < 0)
1949 G4cout << "[" << j << "," << z << "]"
1950 << dimage[j] << ", ";
1951 }
1952 }
1953 }
1954 delete [] shimage;
1955 delete [] di;
1956 if(DEBUG || kVerbose > 0) G4cout << G4endl;
1957
1958 ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
1959 convertEndian(ctmp, iCenter[0]);
1960 convertEndian(ctmp+4, iCenter[1]);
1961 convertEndian(ctmp+8, iCenter[2]);
1962 for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
1963 kDose[ndose].setCenterPosition(fCenter);
1964
1965 if(DEBUG || kVerbose > 0) {
1966 G4cout << "Dose dist. image relative location : ("
1967 << fCenter[0] << ", "
1968 << fCenter[1] << ", "
1969 << fCenter[2] << ")" << G4endl;
1970 }
1971
1972
1973 // dose distribution name
1974 char cname[81];
1975 ifile.read((char *)cname, 80);
1976 std::string dosename = cname;
1977 setDoseDistName(dosename, ndose);
1978 if(DEBUG || kVerbose > 0) {
1979 G4cout << "Dose dist. name : " << dosename << G4endl;
1980 }
1981
1982 }
1983
1984 //----- ROI image -----//
1985 if(kPointerToROIData != 0) {
1986
1987 newROI();
1988
1989 // ROI image size
1990 ifile.read((char *)ctmp, 3*sizeof(int));
1991 convertEndian(ctmp, size[0]);
1992 convertEndian(ctmp+sizeof(int), size[1]);
1993 convertEndian(ctmp+2*sizeof(int), size[2]);
1994 kRoi[0].setSize(size);
1995 if(DEBUG || kVerbose > 0) {
1996 G4cout << "ROI image size : ("
1997 << size[0] << ", "
1998 << size[1] << ", "
1999 << size[2] << ")"
2000 << G4endl;
2001 }
2002
2003 // ROI max. & min.
2004 ifile.read((char *)ctmp, sizeof(short)*2);
2005 convertEndian(ctmp, minmax[0]);
2006 convertEndian(ctmp+sizeof(short), minmax[1]);
2007 kRoi[0].setMinMax(minmax);
2008
2009 // ROI distribution scaling
2010 ifile.read((char *)ctmp, sizeof(float));
2011 convertEndian(ctmp, scale);
2012 kRoi[0].setScale(dscale = scale);
2013 if(DEBUG || kVerbose > 0) {
2014 G4cout << "ROI image min., max., scale : "
2015 << minmax[0] << ", "
2016 << minmax[1] << ", "
2017 << scale << G4endl;
2018 }
2019
2020 // ROI image
2021 int rsize = size[0]*size[1];
2022 char * ri = new char[rsize*sizeof(short)];
2023 for(int i = 0; i < size[2]; i++) {
2024 ifile.read((char *)ri, rsize*sizeof(short));
2025 short * rimage = new short[rsize];
2026 for(int j = 0; j < rsize; j++) {
2027 convertEndian(ri+j*sizeof(short), rimage[j]);
2028 }
2029 kRoi[0].addImage(rimage);
2030
2031 }
2032 delete [] ri;
2033
2034 // ROI relative location
2035 ifile.read((char *)ctmp, 3*sizeof(int));
2036 convertEndian(ctmp, iCenter[0]);
2037 convertEndian(ctmp+sizeof(int), iCenter[1]);
2038 convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2039 for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2040 kRoi[0].setCenterPosition(fCenter);
2041 if(DEBUG || kVerbose > 0) {
2042 G4cout << "ROI image relative location : ("
2043 << fCenter[0] << ", "
2044 << fCenter[1] << ", "
2045 << fCenter[2] << ")" << G4endl;
2046 }
2047
2048 }
2049
2050 //----- track information -----//
2051 if(kPointerToTrackData != 0) {
2052
2053 // track
2054 ifile.read((char *)ctmp, sizeof(int));
2055 int ntrk;
2056 convertEndian(ctmp, ntrk);
2057 if(DEBUG || kVerbose > 0) {
2058 G4cout << "# of tracks: " << ntrk << G4endl;
2059 }
2060
2061 // track position
2062 unsigned char rgb[3];
2063 for(int i = 0; i < ntrk; i++) {
2064
2065
2066 // # of steps in a track
2067 ifile.read((char *)ctmp, sizeof(int));
2068 int nsteps;
2069 convertEndian(ctmp, nsteps);
2070
2071 // track color
2072 ifile.read((char *)rgb, 3);
2073
2074 std::vector<float *> steps;
2075 // steps
2076 for(int j = 0; j < nsteps; j++) {
2077
2078 float * steppoint = new float[6];
2079 ifile.read((char *)ctmp, sizeof(float)*6);
2080
2081 for(int k = 0; k < 6; k++) {
2082 convertEndian(ctmp+k*sizeof(float), steppoint[k]);
2083 }
2084
2085 steps.push_back(steppoint);
2086 }
2087
2088 // add a track to the track container
2089 addTrack(steps, rgb);
2090
2091 if(DEBUG || kVerbose > 0) {
2092 if(i < 5) {
2093 G4cout << i << ": " ;
2094 for(int j = 0; j < 3; j++) G4cout << steps[0][j] << " ";
2095 int nstp = steps.size();
2096 G4cout << "<-> ";
2097 for(int j = 3; j < 6; j++) G4cout << steps[nstp-1][j] << " ";
2098 G4cout << " rgb( ";
2099 for(int j = 0; j < 3; j++) G4cout << (int)rgb[j] << " ";
2100 G4cout << ")" << G4endl;
2101 }
2102 }
2103 }
2104
2105
2106 }
2107
2108
2109 //----- detector information -----//
2110 if(kPointerToDetectorData != 0) {
2111
2112 // number of detectors
2113 ifile.read((char *)ctmp, sizeof(int));
2114 int ndet;
2115 convertEndian(ctmp, ndet);
2116
2117 if(DEBUG || kVerbose > 0) {
2118 G4cout << "# of detectors : "
2119 << ndet << G4endl;
2120 }
2121
2122 for(int nd = 0; nd < ndet; nd++) {
2123
2124 // # of edges of a detector
2125 ifile.read((char *)ctmp, sizeof(int));
2126 int nedges;
2127 convertEndian(ctmp, nedges);
2128 if(DEBUG || kVerbose > 0) {
2129 G4cout << "# of edges in a detector : " << nedges << G4endl;
2130 }
2131
2132 // edges
2133 std::vector<float *> detector;
2134 char cftmp[24];
2135 for(int ne = 0; ne < nedges; ne++) {
2136
2137 ifile.read((char *)cftmp, sizeof(float)*6);
2138 float * edgePoints = new float[6];
2139 for(int j = 0; j < 6; j++) convertEndian(&cftmp[sizeof(float)*j], edgePoints[j]);
2140 detector.push_back(edgePoints);
2141
2142 }
2143
2144 if(DEBUG || kVerbose > 0) {
2145 G4cout << " first edge : (" << detector[0][0] << ", "
2146 << detector[0][1] << ", "
2147 << detector[0][2] << ") - ("
2148 << detector[0][3] << ", "
2149 << detector[0][4] << ", "
2150 << detector[0][5] << ")" << G4endl;
2151 }
2152
2153 // detector color
2154 unsigned char dcolor[3];
2155 ifile.read((char *)dcolor, 3);
2156 if(DEBUG || kVerbose > 0) {
2157 G4cout << " detector color : rgb("
2158 << (int)dcolor[0] << ", "
2159 << (int)dcolor[1] << ", "
2160 << (int)dcolor[2] << G4endl;
2161 }
2162
2163
2164 // detector name
2165 char cname[80];
2166 ifile.read((char *)cname, 80);
2167 std::string dname = cname;
2168 if(DEBUG || kVerbose > 0) {
2169 G4cout << " detector name : " << dname << G4endl;
2170 }
2171
2172
2173 addDetector(dname, detector, dcolor);
2174
2175 }
2176 }
2177
2178
2179 ifile.close();
2180
2181 return true;
2182}
2183bool G4GMocrenIO::retrieveData4(char * _filename) {
2184 kFileName = _filename;
2185 return retrieveData();
2186}
2187
2188//
2189bool G4GMocrenIO::retrieveData3() {
2190
2191 bool DEBUG = false;//
2192
2193 // input file open
2194 std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
2195 if(!ifile) {
2196 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
2197 G4cout << "Cannot open file: " << kFileName
2198 << " in G4GMocrenIO::retrieveData3()." << G4endl;
2199 return false;
2200 }
2201
2202 // data buffer
2203 char ctmp[12];
2204
2205 // file identifier
2206 char verid[9];
2207 ifile.read((char *)verid, 8);
2208
2209 // file version
2210 unsigned char ver;
2211 ifile.read((char *)&ver, 1);
2212 std::stringstream ss;
2213 ss << (int)ver;
2214 kVersion = ss.str();
2215 if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
2216
2217 // endian
2218 ifile.read((char *)&kLittleEndianInput, sizeof(char));
2219 if(DEBUG || kVerbose > 0) {
2220 G4cout << "Endian : ";
2221 if(kLittleEndianInput == 1)
2222 G4cout << " little" << G4endl;
2223 else {
2224 G4cout << " big" << G4endl;
2225 }
2226 }
2227
2228 // comment length (fixed size)
2229 int clength;
2230 ifile.read((char *)ctmp, 4);
2231 convertEndian(ctmp, clength);
2232 // comment
2233 char cmt[1025];
2234 ifile.read((char *)cmt, clength);
2235 std::string scmt = cmt;
2236 setComment(scmt);
2237 if(DEBUG || kVerbose > 0) {
2238 G4cout << "Data comment : "
2239 << kComment << G4endl;
2240 }
2241
2242 // voxel spacings for all images
2243 ifile.read((char *)ctmp, 12);
2244 convertEndian(ctmp, kVoxelSpacing[0]);
2245 convertEndian(ctmp+4, kVoxelSpacing[1]);
2246 convertEndian(ctmp+8, kVoxelSpacing[2]);
2247 if(DEBUG || kVerbose > 0) {
2248 G4cout << "Voxel spacing : ("
2249 << kVoxelSpacing[0] << ", "
2250 << kVoxelSpacing[1] << ", "
2251 << kVoxelSpacing[2]
2252 << ") mm " << G4endl;
2253 }
2254
2255
2256 // offset from file starting point to the modality image data
2257 ifile.read((char *)ctmp, 4);
2258 convertEndian(ctmp, kPointerToModalityData);
2259
2260 // # of dose distributions
2261 ifile.read((char *)ctmp, 4);
2262 int nDoseDist;
2263 convertEndian(ctmp, nDoseDist);
2264
2265 // offset from file starting point to the dose image data
2266 for(int i = 0; i < nDoseDist; i++) {
2267 ifile.read((char *)ctmp, 4);
2268 unsigned int dptr;
2269 convertEndian(ctmp, dptr);
2270 addPointerToDoseDistData(dptr);
2271 }
2272
2273 // offset from file starting point to the ROI image data
2274 ifile.read((char *)ctmp, 4);
2275 convertEndian(ctmp, kPointerToROIData);
2276
2277 // offset from file starting point to the track data
2278 ifile.read((char *)ctmp, 4);
2279 convertEndian(ctmp, kPointerToTrackData);
2280 if(DEBUG || kVerbose > 0) {
2281 G4cout << "Each pointer to data : "
2282 << kPointerToModalityData << ", ";
2283 for(int i = 0; i < nDoseDist; i++)
2284 G4cout << kPointerToDoseDistData[0] << ", ";
2285 G4cout << kPointerToROIData << ", "
2286 << kPointerToTrackData << G4endl;
2287 }
2288
2289 if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
2290 kPointerToROIData == 0 && kPointerToTrackData == 0) {
2291 if(DEBUG || kVerbose > 0) {
2292 G4cout << "No data." << G4endl;
2293 }
2294 return false;
2295 }
2296
2297 // event number
2298 /* ver 1
2299 ifile.read(ctmp, sizeof(int));
2300 convertEndian(ctmp, numberOfEvents);
2301 */
2302
2303 int size[3];
2304 float scale;
2305 double dscale;
2306 short minmax[2];
2307 float fCenter[3];
2308 int iCenter[3];
2309
2310 //----- Modality image -----//
2311 // modality image size
2312 ifile.read(ctmp, 3*sizeof(int));
2313 convertEndian(ctmp, size[0]);
2314 convertEndian(ctmp+sizeof(int), size[1]);
2315 convertEndian(ctmp+2*sizeof(int), size[2]);
2316 if(DEBUG || kVerbose > 0) {
2317 G4cout << "Modality image size : ("
2318 << size[0] << ", "
2319 << size[1] << ", "
2320 << size[2] << ")"
2321 << G4endl;
2322 }
2323 kModality.setSize(size);
2324
2325 // modality image voxel spacing
2326 /*
2327 ifile.read(ctmp, 3*sizeof(float));
2328 convertEndian(ctmp, modalityImageVoxelSpacing[0]);
2329 convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
2330 convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
2331 */
2332
2333 if(kPointerToModalityData != 0) {
2334
2335 // modality density max. & min.
2336 ifile.read((char *)ctmp, 4);
2337 convertEndian(ctmp, minmax[0]);
2338 convertEndian(ctmp+2, minmax[1]);
2339 kModality.setMinMax(minmax);
2340
2341 // modality image unit
2342 char munit[13];
2343 ifile.read((char *)munit, 12);
2344 std::string smunit = munit;
2345 setModalityImageUnit(smunit);
2346
2347 // modality density scale
2348 ifile.read((char *)ctmp, 4);
2349 convertEndian(ctmp, scale);
2350 kModality.setScale(dscale = scale);
2351 if(DEBUG || kVerbose > 0) {
2352 G4cout << "Modality image min., max., scale : "
2353 << minmax[0] << ", "
2354 << minmax[1] << ", "
2355 << scale << G4endl;
2356 }
2357
2358 // modality density
2359 int psize = size[0]*size[1];
2360 if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
2361 char * cimage = new char[psize*sizeof(short)];
2362 for(int i = 0; i < size[2]; i++) {
2363 ifile.read((char *)cimage, psize*sizeof(short));
2364 short * mimage = new short[psize];
2365 for(int j = 0; j < psize; j++) {
2366 convertEndian(cimage+j*sizeof(short), mimage[j]);
2367 }
2368 kModality.addImage(mimage);
2369
2370 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
2371 }
2372 if(DEBUG || kVerbose > 0) G4cout << G4endl;
2373 delete [] cimage;
2374
2375 // modality desity map for CT value
2376 size_t msize = minmax[1]-minmax[0]+1;
2377 if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
2378 char * pdmap = new char[msize*sizeof(float)];
2379 ifile.read((char *)pdmap, msize*sizeof(float));
2380 float ftmp;
2381 for(int i = 0; i < (int)msize; i++) {
2382 convertEndian(pdmap+i*sizeof(float), ftmp);
2383 kModalityImageDensityMap.push_back(ftmp);
2384 }
2385 delete [] pdmap;
2386 if(DEBUG || kVerbose > 0) {
2387 G4cout << "density map : " << std::ends;
2388 for(int i = 0; i < 10; i++)
2389 G4cout <<kModalityImageDensityMap[i] << ", ";
2390 G4cout << G4endl;
2391 for(int i = 0; i < 10; i++) G4cout << "..";
2392 G4cout << G4endl;
2393 for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
2394 G4cout <<kModalityImageDensityMap[i] << ", ";
2395 G4cout << G4endl;
2396 }
2397
2398 }
2399
2400
2401 //----- dose distribution image -----//
2402 for(int ndose = 0; ndose < nDoseDist; ndose++) {
2403
2404 newDoseDist();
2405
2406 // dose distrbution image size
2407 ifile.read((char *)ctmp, 3*sizeof(int));
2408 convertEndian(ctmp, size[0]);
2409 convertEndian(ctmp+sizeof(int), size[1]);
2410 convertEndian(ctmp+2*sizeof(int), size[2]);
2411 if(DEBUG || kVerbose > 0) {
2412 G4cout << "Dose dist. image size : ("
2413 << size[0] << ", "
2414 << size[1] << ", "
2415 << size[2] << ")"
2416 << G4endl;
2417 }
2418 kDose[ndose].setSize(size);
2419
2420 // dose distribution max. & min.
2421 ifile.read((char *)ctmp, sizeof(short)*2);
2422 convertEndian(ctmp, minmax[0]);
2423 convertEndian(ctmp+2, minmax[1]);
2424
2425 // dose distribution unit
2426 char dunit[13];
2427 ifile.read((char *)dunit, 12);
2428 std::string sdunit = dunit;
2429 setDoseDistUnit(sdunit, ndose);
2430 if(DEBUG || kVerbose > 0) {
2431 G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
2432 }
2433
2434 // dose distribution scaling
2435 ifile.read((char *)ctmp, 4); // sizeof(float)
2436 convertEndian(ctmp, scale);
2437 kDose[ndose].setScale(dscale = scale);
2438
2439 double dminmax[2];
2440 for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
2441 kDose[ndose].setMinMax(dminmax);
2442
2443 if(DEBUG || kVerbose > 0) {
2444 G4cout << "Dose dist. image min., max., scale : "
2445 << dminmax[0] << ", "
2446 << dminmax[1] << ", "
2447 << scale << G4endl;
2448 }
2449
2450 // dose distribution image
2451 int dsize = size[0]*size[1];
2452 if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
2453 char * di = new char[dsize*sizeof(short)];
2454 short * shimage = new short[dsize];
2455 for(int z = 0; z < size[2]; z++) {
2456 ifile.read((char *)di, dsize*sizeof(short));
2457 double * dimage = new double[dsize];
2458 for(int xy = 0; xy < dsize; xy++) {
2459 convertEndian(di+xy*sizeof(short), shimage[xy]);
2460 dimage[xy] = shimage[xy]*dscale;
2461 }
2462 kDose[ndose].addImage(dimage);
2463
2464 if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
2465
2466 if(DEBUG || kVerbose > 0) {
2467 for(int j = 0; j < dsize; j++) {
2468 if(dimage[j] < 0)
2469 G4cout << "[" << j << "," << z << "]"
2470 << dimage[j] << ", ";
2471 }
2472 }
2473 }
2474 delete [] shimage;
2475 delete [] di;
2476 if(DEBUG || kVerbose > 0) G4cout << G4endl;
2477
2478 ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
2479 convertEndian(ctmp, iCenter[0]);
2480 convertEndian(ctmp+4, iCenter[1]);
2481 convertEndian(ctmp+8, iCenter[2]);
2482 for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
2483 kDose[ndose].setCenterPosition(fCenter);
2484
2485 if(DEBUG || kVerbose > 0) {
2486 G4cout << "Dose dist. image relative location : ("
2487 << fCenter[0] << ", "
2488 << fCenter[1] << ", "
2489 << fCenter[2] << ")" << G4endl;
2490 }
2491
2492
2493 }
2494
2495 //----- ROI image -----//
2496 if(kPointerToROIData != 0) {
2497
2498 newROI();
2499
2500 // ROI image size
2501 ifile.read((char *)ctmp, 3*sizeof(int));
2502 convertEndian(ctmp, size[0]);
2503 convertEndian(ctmp+sizeof(int), size[1]);
2504 convertEndian(ctmp+2*sizeof(int), size[2]);
2505 kRoi[0].setSize(size);
2506 if(DEBUG || kVerbose > 0) {
2507 G4cout << "ROI image size : ("
2508 << size[0] << ", "
2509 << size[1] << ", "
2510 << size[2] << ")"
2511 << G4endl;
2512 }
2513
2514 // ROI max. & min.
2515 ifile.read((char *)ctmp, sizeof(short)*2);
2516 convertEndian(ctmp, minmax[0]);
2517 convertEndian(ctmp+sizeof(short), minmax[1]);
2518 kRoi[0].setMinMax(minmax);
2519
2520 // ROI distribution scaling
2521 ifile.read((char *)ctmp, sizeof(float));
2522 convertEndian(ctmp, scale);
2523 kRoi[0].setScale(dscale = scale);
2524 if(DEBUG || kVerbose > 0) {
2525 G4cout << "ROI image min., max., scale : "
2526 << minmax[0] << ", "
2527 << minmax[1] << ", "
2528 << scale << G4endl;
2529 }
2530
2531 // ROI image
2532 int rsize = size[0]*size[1];
2533 char * ri = new char[rsize*sizeof(short)];
2534 for(int i = 0; i < size[2]; i++) {
2535 ifile.read((char *)ri, rsize*sizeof(short));
2536 short * rimage = new short[rsize];
2537 for(int j = 0; j < rsize; j++) {
2538 convertEndian(ri+j*sizeof(short), rimage[j]);
2539 }
2540 kRoi[0].addImage(rimage);
2541
2542 }
2543 delete [] ri;
2544
2545 // ROI relative location
2546 ifile.read((char *)ctmp, 3*sizeof(int));
2547 convertEndian(ctmp, iCenter[0]);
2548 convertEndian(ctmp+sizeof(int), iCenter[1]);
2549 convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2550 for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2551 kRoi[0].setCenterPosition(fCenter);
2552 if(DEBUG || kVerbose > 0) {
2553 G4cout << "ROI image relative location : ("
2554 << fCenter[0] << ", "
2555 << fCenter[1] << ", "
2556 << fCenter[2] << ")" << G4endl;
2557 }
2558
2559 }
2560
2561 //----- track information -----//
2562 if(kPointerToTrackData != 0) {
2563
2564 // track
2565 ifile.read((char *)ctmp, sizeof(int));
2566 int ntrk;
2567 convertEndian(ctmp, ntrk);
2568 if(DEBUG || kVerbose > 0) {
2569 G4cout << "# of tracks: " << ntrk << G4endl;
2570 }
2571
2572 // v4
2573 std::vector<float *> trkv4;
2574
2575 // track position
2576 for(int i = 0; i < ntrk; i++) {
2577 float * tp = new float[6];
2578
2579 ifile.read((char *)ctmp, sizeof(float)*3);
2580 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
2581 for(int j = 0; j < 3; j++) {
2582 convertEndian(ctmp+j*sizeof(float), tp[j]);
2583 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
2584 }
2585
2586 ifile.read((char *)ctmp, sizeof(float)*3);
2587 for(int j = 0; j < 3; j++) {
2588 convertEndian(ctmp+j*sizeof(float), tp[j+3]);
2589 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
2590 }
2591 addTrack(tp);
2592 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
2593
2594 // v4
2595 trkv4.push_back(tp);
2596 }
2597
2598 //v4
2599 unsigned char trkcolorv4[3];
2600
2601 // track color
2602 for(int i = 0; i < ntrk; i++) {
2603 unsigned char * rgb = new unsigned char[3];
2604 ifile.read((char *)rgb, 3);
2605 addTrackColor(rgb);
2606
2607 // v4
2608 for(int j = 0; j < 3; j++) trkcolorv4[j] = rgb[j];
2609 std::vector<float *> trk;
2610 trk.push_back(trkv4[i]);
2611 addTrack(trk, trkcolorv4);
2612
2613 }
2614
2615 }
2616
2617 ifile.close();
2618
2619 return true;
2620}
2621bool G4GMocrenIO::retrieveData3(char * _filename) {
2622 kFileName = _filename;
2623 return retrieveData();
2624}
2625
2626//
2627bool G4GMocrenIO::retrieveData2() {
2628
2629 bool DEBUG = false;//
2630
2631 // input file open
2632 std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
2633 if(!ifile) {
2634 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
2635 G4cout << "Cannot open file: " << kFileName
2636 << " in G4GMocrenIO::retrieveData2()." << G4endl;
2637 return false;
2638 }
2639
2640 // data buffer
2641 char ctmp[12];
2642
2643 // file identifier
2644 char verid[9];
2645 ifile.read((char *)verid, 8);
2646
2647 // file version
2648 unsigned char ver;
2649 ifile.read((char *)&ver, 1);
2650 std::stringstream ss;
2651 ss << (int)ver;
2652 kVersion = ss.str();
2653 if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
2654
2655 // id of version 1
2656 char idtmp[IDLENGTH];
2657 ifile.read((char *)idtmp, IDLENGTH);
2658 kId = idtmp;
2659 // version of version 1
2660 char vertmp[VERLENGTH];
2661 ifile.read((char *)vertmp, VERLENGTH);
2662
2663 // endian
2664 ifile.read((char *)&kLittleEndianInput, sizeof(char));
2665 if(DEBUG || kVerbose > 0) {
2666 G4cout << "Endian : ";
2667 if(kLittleEndianInput == 1)
2668 G4cout << " little" << G4endl;
2669 else {
2670 G4cout << " big" << G4endl;
2671 }
2672 }
2673
2674 // voxel spacings for all images
2675 ifile.read((char *)ctmp, 12);
2676 convertEndian(ctmp, kVoxelSpacing[0]);
2677 convertEndian(ctmp+4, kVoxelSpacing[1]);
2678 convertEndian(ctmp+8, kVoxelSpacing[2]);
2679 if(DEBUG || kVerbose > 0) {
2680 G4cout << "Voxel spacing : ("
2681 << kVoxelSpacing[0] << ", "
2682 << kVoxelSpacing[1] << ", "
2683 << kVoxelSpacing[2]
2684 << ") mm " << G4endl;
2685 }
2686
2687
2688 // offset from file starting point to the modality image data
2689 ifile.read((char *)ctmp, 4);
2690 convertEndian(ctmp, kPointerToModalityData);
2691
2692 // offset from file starting point to the dose image data
2693 unsigned int ptddd;
2694 ifile.read((char *)ctmp, 4);
2695 convertEndian(ctmp, ptddd);
2696 kPointerToDoseDistData.push_back(ptddd);
2697
2698 // offset from file starting point to the ROI image data
2699 ifile.read((char *)ctmp, 4);
2700 convertEndian(ctmp, kPointerToROIData);
2701
2702 // offset from file starting point to the track data
2703 ifile.read((char *)ctmp, 4);
2704 convertEndian(ctmp, kPointerToTrackData);
2705 if(DEBUG || kVerbose > 0) {
2706 G4cout << "Each pointer to data : "
2707 << kPointerToModalityData << ", "
2708 << kPointerToDoseDistData[0] << ", "
2709 << kPointerToROIData << ", "
2710 << kPointerToTrackData << G4endl;
2711 }
2712
2713 if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
2714 kPointerToROIData == 0 && kPointerToTrackData == 0) {
2715 if(DEBUG || kVerbose > 0) {
2716 G4cout << "No data." << G4endl;
2717 }
2718 return false;
2719 }
2720
2721 // event number
2722 /* ver 1
2723 ifile.read(ctmp, sizeof(int));
2724 convertEndian(ctmp, numberOfEvents);
2725 */
2726
2727 int size[3];
2728 float scale;
2729 double dscale;
2730 short minmax[2];
2731 float fCenter[3];
2732 int iCenter[3];
2733
2734 //----- Modality image -----//
2735 // modality image size
2736 ifile.read(ctmp, 3*sizeof(int));
2737 convertEndian(ctmp, size[0]);
2738 convertEndian(ctmp+sizeof(int), size[1]);
2739 convertEndian(ctmp+2*sizeof(int), size[2]);
2740 if(DEBUG || kVerbose > 0) {
2741 G4cout << "Modality image size : ("
2742 << size[0] << ", "
2743 << size[1] << ", "
2744 << size[2] << ")"
2745 << G4endl;
2746 }
2747 kModality.setSize(size);
2748
2749 // modality image voxel spacing
2750 /*
2751 ifile.read(ctmp, 3*sizeof(float));
2752 convertEndian(ctmp, modalityImageVoxelSpacing[0]);
2753 convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
2754 convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
2755 */
2756
2757 if(kPointerToModalityData != 0) {
2758
2759 // modality density max. & min.
2760 ifile.read((char *)ctmp, 4);
2761 convertEndian(ctmp, minmax[0]);
2762 convertEndian(ctmp+2, minmax[1]);
2763 kModality.setMinMax(minmax);
2764
2765 // modality density scale
2766 ifile.read((char *)ctmp, 4);
2767 convertEndian(ctmp, scale);
2768 kModality.setScale(dscale = scale);
2769 if(DEBUG || kVerbose > 0) {
2770 G4cout << "Modality image min., max., scale : "
2771 << minmax[0] << ", "
2772 << minmax[1] << ", "
2773 << scale << G4endl;
2774 }
2775
2776 // modality density
2777 int psize = size[0]*size[1];
2778 if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
2779 char * cimage = new char[psize*sizeof(short)];
2780 for(int i = 0; i < size[2]; i++) {
2781 ifile.read((char *)cimage, psize*sizeof(short));
2782 short * mimage = new short[psize];
2783 for(int j = 0; j < psize; j++) {
2784 convertEndian(cimage+j*sizeof(short), mimage[j]);
2785 }
2786 kModality.addImage(mimage);
2787
2788 if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
2789 }
2790 if(DEBUG || kVerbose > 0) G4cout << G4endl;
2791 delete [] cimage;
2792
2793 // modality desity map for CT value
2794 size_t msize = minmax[1]-minmax[0]+1;
2795 if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
2796 char * pdmap = new char[msize*sizeof(float)];
2797 ifile.read((char *)pdmap, msize*sizeof(float));
2798 float ftmp;
2799 for(int i = 0; i < (int)msize; i++) {
2800 convertEndian(pdmap+i*sizeof(float), ftmp);
2801 kModalityImageDensityMap.push_back(ftmp);
2802 }
2803 delete [] pdmap;
2804 if(DEBUG || kVerbose > 0) {
2805 G4cout << "density map : " << std::ends;
2806 for(int i = 0; i < 10; i++)
2807 G4cout <<kModalityImageDensityMap[i] << ", ";
2808 G4cout << G4endl;
2809 for(int i = 0; i < 10; i++) G4cout << "..";
2810 G4cout << G4endl;
2811 for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
2812 G4cout <<kModalityImageDensityMap[i] << ", ";
2813 G4cout << G4endl;
2814 }
2815
2816 }
2817
2818
2819 //----- dose distribution image -----//
2820 if(kPointerToDoseDistData[0] != 0) {
2821
2822 newDoseDist();
2823
2824 // dose distrbution image size
2825 ifile.read((char *)ctmp, 3*sizeof(int));
2826 convertEndian(ctmp, size[0]);
2827 convertEndian(ctmp+sizeof(int), size[1]);
2828 convertEndian(ctmp+2*sizeof(int), size[2]);
2829 if(DEBUG || kVerbose > 0) {
2830 G4cout << "Dose dist. image size : ("
2831 << size[0] << ", "
2832 << size[1] << ", "
2833 << size[2] << ")"
2834 << G4endl;
2835 }
2836 kDose[0].setSize(size);
2837
2838 // dose distribution max. & min.
2839 ifile.read((char *)ctmp, sizeof(short)*2);
2840 convertEndian(ctmp, minmax[0]);
2841 convertEndian(ctmp+2, minmax[1]);
2842 // dose distribution scaling
2843 ifile.read((char *)ctmp, sizeof(float));
2844 convertEndian(ctmp, scale);
2845 kDose[0].setScale(dscale = scale);
2846
2847 double dminmax[2];
2848 for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
2849 kDose[0].setMinMax(dminmax);
2850
2851 if(DEBUG || kVerbose > 0) {
2852 G4cout << "Dose dist. image min., max., scale : "
2853 << dminmax[0] << ", "
2854 << dminmax[1] << ", "
2855 << scale << G4endl;
2856 }
2857
2858 // dose distribution image
2859 int dsize = size[0]*size[1];
2860 if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
2861 char * di = new char[dsize*sizeof(short)];
2862 short * shimage = new short[dsize];
2863 for(int z = 0; z < size[2]; z++) {
2864 ifile.read((char *)di, dsize*sizeof(short));
2865 double * dimage = new double[dsize];
2866 for(int xy = 0; xy < dsize; xy++) {
2867 convertEndian(di+xy*sizeof(short), shimage[xy]);
2868 dimage[xy] = shimage[xy]*dscale;
2869 }
2870 kDose[0].addImage(dimage);
2871
2872 if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
2873
2874 if(DEBUG || kVerbose > 0) {
2875 for(int j = 0; j < dsize; j++) {
2876 if(dimage[j] < 0)
2877 G4cout << "[" << j << "," << z << "]"
2878 << dimage[j] << ", ";
2879 }
2880 }
2881 }
2882 delete [] shimage;
2883 delete [] di;
2884 if(DEBUG || kVerbose > 0) G4cout << G4endl;
2885
2886 /* ver 1
2887 float doseDist;
2888 int dosePid;
2889 double * doseData = new double[numDoseImageVoxels];
2890 for(int i = 0; i < numDose; i++) {
2891 ifile.read(ctmp, sizeof(int));
2892 convertEndian(ctmp, dosePid);
2893 for(int j = 0; j < numDoseImageVoxels; j++) {
2894 ifile.read(ctmp, sizeof(float));
2895 convertEndian(ctmp, doseDist);
2896 doseData[j] = doseDist;
2897 }
2898 setDose(dosePid, doseData);
2899 }
2900 delete [] doseData;
2901 if(totalDose == NULL) totalDose = new double[numDoseImageVoxels];
2902 for(int i = 0; i < numDoseImageVoxels; i++) {
2903 ifile.read(ctmp, sizeof(float));
2904 convertEndian(ctmp, doseDist);
2905 totalDose[i] = doseDist;
2906 }
2907 */
2908
2909 /* ver 1
2910 // relative location between the two images
2911 ifile.read(ctmp, 3*sizeof(float));
2912 convertEndian(ctmp, relativeLocation[0]);
2913 convertEndian(ctmp+sizeof(float), relativeLocation[1]);
2914 convertEndian(ctmp+2*sizeof(float), relativeLocation[2]);
2915 */
2916
2917 // relative location of the dose distribution image for
2918 // the modality image
2919 //ofile.write((char *)relativeLocation, 3*sizeof(float));
2920 ifile.read((char *)ctmp, 3*sizeof(int));
2921 convertEndian(ctmp, iCenter[0]);
2922 convertEndian(ctmp+sizeof(int), iCenter[1]);
2923 convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2924 for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
2925 kDose[0].setCenterPosition(fCenter);
2926
2927 if(DEBUG || kVerbose > 0) {
2928 G4cout << "Dose dist. image relative location : ("
2929 << fCenter[0] << ", "
2930 << fCenter[1] << ", "
2931 << fCenter[2] << ")" << G4endl;
2932 }
2933
2934
2935 }
2936
2937 //----- ROI image -----//
2938 if(kPointerToROIData != 0) {
2939
2940 newROI();
2941
2942 // ROI image size
2943 ifile.read((char *)ctmp, 3*sizeof(int));
2944 convertEndian(ctmp, size[0]);
2945 convertEndian(ctmp+sizeof(int), size[1]);
2946 convertEndian(ctmp+2*sizeof(int), size[2]);
2947 kRoi[0].setSize(size);
2948 if(DEBUG || kVerbose > 0) {
2949 G4cout << "ROI image size : ("
2950 << size[0] << ", "
2951 << size[1] << ", "
2952 << size[2] << ")"
2953 << G4endl;
2954 }
2955
2956 // ROI max. & min.
2957 ifile.read((char *)ctmp, sizeof(short)*2);
2958 convertEndian(ctmp, minmax[0]);
2959 convertEndian(ctmp+sizeof(short), minmax[1]);
2960 kRoi[0].setMinMax(minmax);
2961
2962 // ROI distribution scaling
2963 ifile.read((char *)ctmp, sizeof(float));
2964 convertEndian(ctmp, scale);
2965 kRoi[0].setScale(dscale = scale);
2966 if(DEBUG || kVerbose > 0) {
2967 G4cout << "ROI image min., max., scale : "
2968 << minmax[0] << ", "
2969 << minmax[1] << ", "
2970 << scale << G4endl;
2971 }
2972
2973 // ROI image
2974 int rsize = size[0]*size[1];
2975 char * ri = new char[rsize*sizeof(short)];
2976 for(int i = 0; i < size[2]; i++) {
2977 ifile.read((char *)ri, rsize*sizeof(short));
2978 short * rimage = new short[rsize];
2979 for(int j = 0; j < rsize; j++) {
2980 convertEndian(ri+j*sizeof(short), rimage[j]);
2981 }
2982 kRoi[0].addImage(rimage);
2983
2984 }
2985 delete [] ri;
2986
2987 // ROI relative location
2988 ifile.read((char *)ctmp, 3*sizeof(int));
2989 convertEndian(ctmp, iCenter[0]);
2990 convertEndian(ctmp+sizeof(int), iCenter[1]);
2991 convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2992 for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2993 kRoi[0].setCenterPosition(fCenter);
2994 if(DEBUG || kVerbose > 0) {
2995 G4cout << "ROI image relative location : ("
2996 << fCenter[0] << ", "
2997 << fCenter[1] << ", "
2998 << fCenter[2] << ")" << G4endl;
2999 }
3000
3001 }
3002
3003 //----- track information -----//
3004 if(kPointerToTrackData != 0) {
3005
3006 // track
3007 ifile.read((char *)ctmp, sizeof(int));
3008 int ntrk;
3009 convertEndian(ctmp, ntrk);
3010 if(DEBUG || kVerbose > 0) {
3011 G4cout << "# of tracks: " << ntrk << G4endl;
3012 }
3013
3014 //v4
3015 unsigned char trkcolorv4[3] = {255, 0, 0};
3016
3017 for(int i = 0; i < ntrk; i++) {
3018 float * tp = new float[6];
3019 // v4
3020 std::vector<float *> trkv4;
3021
3022 ifile.read((char *)ctmp, sizeof(float)*3);
3023 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
3024 for(int j = 0; j < 3; j++) {
3025 convertEndian(ctmp+j*sizeof(float), tp[j]);
3026 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
3027 }
3028
3029 ifile.read((char *)ctmp, sizeof(float)*3);
3030 for(int j = 0; j < 3; j++) {
3031 convertEndian(ctmp+j*sizeof(float), tp[j+3]);
3032 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
3033 }
3034
3035 kSteps.push_back(tp);
3036 // v4
3037 trkv4.push_back(tp);
3038 addTrack(trkv4, trkcolorv4);
3039
3040 if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
3041 }
3042
3043 }
3044
3045 /* ver 1
3046 // track
3047 int ntracks;
3048 ifile.read(ctmp, sizeof(int));
3049 convertEndian(ctmp, ntracks);
3050 // track displacement
3051 ifile.read(ctmp, 3*sizeof(float));
3052 convertEndian(ctmp, trackDisplacement[0]);
3053 convertEndian(ctmp+sizeof(float), trackDisplacement[2]); // exchanged with [1]
3054 convertEndian(ctmp+2*sizeof(float), trackDisplacement[1]);
3055 //
3056 //for(int i = 0; i < ntracks && i < 100; i++) {
3057 for(int i = 0; i < ntracks; i++) {
3058 DicomDoseTrack trk;
3059 short trackid, parentid, pid;
3060 int npoints;
3061 ifile.read(ctmp, sizeof(short));
3062 convertEndian(ctmp, trackid);
3063 trk.setID(trackid);
3064 ifile.read(ctmp, sizeof(short));
3065 convertEndian(ctmp, parentid);
3066 trk.setParentID(parentid);
3067 ifile.read(ctmp, sizeof(short));
3068 convertEndian(ctmp, pid);
3069 trk.setPID(pid);
3070 ifile.read(ctmp, sizeof(int));
3071 convertEndian(ctmp, npoints);
3072 for(int i = 0; i < npoints; i++) {
3073 ifile.read(ctmp, 3*sizeof(float));
3074 // storing only start and end points
3075 //if(i == 0 || i == npoints - 1) {
3076 float * point = new float[3];
3077 convertEndian(ctmp, point[0]);
3078 convertEndian(ctmp+sizeof(float), point[1]);
3079 convertEndian(ctmp+2*sizeof(float), point[2]);
3080 trk.addPoint(point);
3081 //}
3082 }
3083 track.push_back(trk);
3084 }
3085 */
3086
3087 ifile.close();
3088
3089 return true;
3090}
3091
3092bool G4GMocrenIO::retrieveData2(char * _filename) {
3093 kFileName = _filename;
3094 return retrieveData();
3095}
3096
3097void G4GMocrenIO::setID() {
3098 time_t t;
3099 time(&t);
3100
3101 tm * ti;
3102 ti = localtime(&t);
3103
3104 char cmonth[12][4] = {"Jan", "Feb", "Mar", "Apr",
3105 "May", "Jun", "Jul", "Aug",
3106 "Sep", "Oct", "Nov", "Dec"};
3107 std::stringstream ss;
3108 ss << std::setfill('0')
3109 << std::setw(2)
3110 << ti->tm_hour << ":"
3111 << std::setw(2)
3112 << ti->tm_min << ":"
3113 << std::setw(2)
3114 << ti->tm_sec << ","
3115 << cmonth[ti->tm_mon] << "."
3116 << std::setw(2)
3117 << ti->tm_mday << ","
3118 << ti->tm_year+1900;
3119
3120 kId = ss.str();
3121}
3122
3123// get & set the file version
3124std::string & G4GMocrenIO::getVersion() {return kVersion;}
3125void G4GMocrenIO::setVersion(std::string & _version) {kVersion = _version;}
3126
3127// set endians of input/output data
3128void G4GMocrenIO::setLittleEndianInput(bool _little) {kLittleEndianInput = _little;}
3129void G4GMocrenIO::setLittleEndianOutput(bool _little) {kLittleEndianOutput = _little;}
3130
3131// voxel spacing
3132void G4GMocrenIO::setVoxelSpacing(float _spacing[3]) {
3133 for(int i = 0; i < 3; i++) kVoxelSpacing[i] = _spacing[i];
3134}
3135void G4GMocrenIO::getVoxelSpacing(float _spacing[3]) {
3136 for(int i = 0; i < 3; i++) _spacing[i] = kVoxelSpacing[i];
3137}
3138
3139// get & set number of events
3140int & G4GMocrenIO::getNumberOfEvents() {
3141 return kNumberOfEvents;
3142}
3143void G4GMocrenIO::setNumberOfEvents(int & _numberOfEvents) {
3144 kNumberOfEvents = _numberOfEvents;
3145}
3146void G4GMocrenIO::addOneEvent() {
3147 kNumberOfEvents++;
3148}
3149
3150// set/get pointer the modality image data
3151void G4GMocrenIO::setPointerToModalityData(unsigned int & _pointer) {
3152 kPointerToModalityData = _pointer;
3153}
3154unsigned int G4GMocrenIO::getPointerToModalityData() {
3155 return kPointerToModalityData;
3156}
3157// set/get pointer the dose distribution image data
3158void G4GMocrenIO::addPointerToDoseDistData(unsigned int & _pointer) {
3159 kPointerToDoseDistData.push_back(_pointer);
3160}
3161unsigned int G4GMocrenIO::getPointerToDoseDistData(int _elem) {
3162 if(kPointerToDoseDistData.size() == 0 ||
3163 kPointerToDoseDistData.size() < (size_t)_elem)
3164 return 0;
3165 else
3166 return kPointerToDoseDistData[_elem];
3167}
3168
3169// set/get pointer the ROI image data
3170void G4GMocrenIO::setPointerToROIData(unsigned int & _pointer) {
3171 kPointerToROIData = _pointer;
3172}
3173unsigned int G4GMocrenIO::getPointerToROIData() {
3174 return kPointerToROIData;
3175}
3176// set/get pointer the track data
3177void G4GMocrenIO::setPointerToTrackData(unsigned int & _pointer) {
3178 kPointerToTrackData = _pointer;
3179}
3180unsigned int G4GMocrenIO::getPointerToTrackData() {
3181 return kPointerToTrackData;
3182}
3183
3184// calculate pointers for version 4
3185void G4GMocrenIO::calcPointers4() {
3186
3187 // pointer to modality data
3188 unsigned int pointer = 1070; // up to "pointer to the detector data" except for "pointer to the dose dist data"
3189 int nDoseDist = getNumDoseDist();
3190 pointer += nDoseDist*4;
3191
3192 setPointerToModalityData(pointer);
3193
3194 // pointer to dose data
3195 // ct-density map for modality data
3196 int msize[3];
3197 getModalityImageSize(msize);
3198 short mminmax[2];
3199 getModalityImageMinMax(mminmax);
3200 int pmsize = 2*msize[0]*msize[1]*msize[2];
3201 int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3202 pointer += 32 + pmsize + pmmap;
3203 //
3204 kPointerToDoseDistData.clear();
3205 if(nDoseDist == 0) {
3206 unsigned int pointer0 = 0;
3207 addPointerToDoseDistData(pointer0);
3208 }
3209 for(int ndose = 0; ndose < nDoseDist; ndose++) {
3210 addPointerToDoseDistData(pointer);
3211 int dsize[3];
3212 getDoseDistSize(dsize);
3213 pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2 + 80;
3214 }
3215
3216 // pointer to roi data
3217 if(!isROIEmpty()) {
3218 setPointerToROIData(pointer);
3219
3220 int rsize[3];
3221 getROISize(rsize);
3222 int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3223 pointer += 20 + prsize + 12;
3224 } else {
3225 unsigned int pointer0 = 0;
3226 setPointerToROIData(pointer0);
3227 }
3228
3229 // pointer to track data
3230 int ntrk = kTracks.size();
3231 if(ntrk != 0) {
3232 setPointerToTrackData(pointer);
3233
3234 pointer += 4; // # of tracks
3235 for(int nt = 0; nt < ntrk; nt++) {
3236 int nsteps = kTracks[nt].getNumberOfSteps();
3237 pointer += 4 + 3 + nsteps*(4*6); // # of steps + color + steps(float*6)
3238 }
3239 } else {
3240 unsigned int pointer0 = 0;
3241 setPointerToTrackData(pointer0);
3242 }
3243 if(kVerbose > 0) G4cout << " pointer to the track data :"
3244 << kPointerToTrackData << G4endl;
3245
3246 // pointer to detector data
3247 int ndet = kDetectors.size();
3248 if(ndet != 0) {
3249 kPointerToDetectorData = pointer;
3250 } else {
3251 kPointerToDetectorData = 0;
3252 }
3253 if(kVerbose > 0) G4cout << " pointer to the detector data :"
3254 << kPointerToDetectorData << G4endl;
3255
3256}
3257
3258// calculate pointers for ver.3
3259void G4GMocrenIO::calcPointers3() {
3260
3261 // pointer to modality data
3262 unsigned int pointer = 1066; // up to "pointer to the track data" except for "pointer to the dose dist data"
3263 int nDoseDist = getNumDoseDist();
3264 pointer += nDoseDist*4;
3265
3266 setPointerToModalityData(pointer);
3267
3268 // pointer to dose data
3269 // ct-density map for modality data
3270 int msize[3];
3271 getModalityImageSize(msize);
3272 short mminmax[2];
3273 getModalityImageMinMax(mminmax);
3274 int pmsize = 2*msize[0]*msize[1]*msize[2];
3275 int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3276 pointer += 32 + pmsize + pmmap;
3277 //
3278 kPointerToDoseDistData.clear();
3279 if(nDoseDist == 0) {
3280 unsigned int pointer0 = 0;
3281 addPointerToDoseDistData(pointer0);
3282 }
3283 for(int ndose = 0; ndose < nDoseDist; ndose++) {
3284 addPointerToDoseDistData(pointer);
3285 int dsize[3];
3286 getDoseDistSize(dsize);
3287 pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2;
3288 }
3289
3290 // pointer to roi data
3291 if(!isROIEmpty()) {
3292 setPointerToROIData(pointer);
3293
3294 int rsize[3];
3295 getROISize(rsize);
3296 int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3297 pointer += 20 + prsize + 12;
3298 } else {
3299 unsigned int pointer0 = 0;
3300 setPointerToROIData(pointer0);
3301 }
3302
3303 //
3304 if(getNumTracks() != 0)
3305 setPointerToTrackData(pointer);
3306 else {
3307 unsigned int pointer0 = 0;
3308 setPointerToTrackData(pointer0);
3309 }
3310
3311}
3312
3313// calculate pointers for ver.2
3314void G4GMocrenIO::calcPointers2() {
3315
3316 // pointer to modality data
3317 unsigned int pointer = 65;
3318 setPointerToModalityData(pointer);
3319
3320 // pointer to dose data
3321 int msize[3];
3322 getModalityImageSize(msize);
3323 short mminmax[2];
3324 getModalityImageMinMax(mminmax);
3325 int pmsize = 2*msize[0]*msize[1]*msize[2];
3326 int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3327 pointer += 20 + pmsize + pmmap;
3328 int dsize[3];
3329 getDoseDistSize(dsize);
3330 kPointerToDoseDistData.clear();
3331 if(dsize[0] != 0) {
3332 kPointerToDoseDistData.push_back(pointer);
3333
3334 int pdsize = 2*dsize[0]*dsize[1]*dsize[2];
3335 pointer += 20 + pdsize + 12;
3336 } else {
3337 unsigned int pointer0 = 0;
3338 kPointerToDoseDistData.push_back(pointer0);
3339 }
3340
3341 // pointer to roi data
3342 if(!isROIEmpty()) {
3343 int rsize[3];
3344 getROISize(rsize);
3345 setPointerToROIData(pointer);
3346 int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3347 pointer += 20 + prsize + 12;
3348
3349 } else {
3350 unsigned int pointer0 = 0;
3351 setPointerToROIData(pointer0);
3352 }
3353
3354 //
3355 if(getNumTracks() != 0)
3356 setPointerToTrackData(pointer);
3357 else {
3358 unsigned int pointer0 = 0;
3359 setPointerToTrackData(pointer0);
3360 }
3361
3362}
3363
3364
3365//----- Modality image -----//
3366void G4GMocrenIO::getModalityImageSize(int _size[3]) {
3367
3368 kModality.getSize(_size);
3369}
3370void G4GMocrenIO::setModalityImageSize(int _size[3]) {
3371
3372 kModality.setSize(_size);
3373}
3374
3375// get & set the modality image size
3376void G4GMocrenIO::setModalityImageScale(double & _scale) {
3377
3378 kModality.setScale(_scale);
3379}
3380double G4GMocrenIO::getModalityImageScale() {
3381
3382 return kModality.getScale();
3383}
3384
3385// set the modality image in CT
3386void G4GMocrenIO::setModalityImage(short * _image) {
3387
3388 kModality.addImage(_image);
3389}
3390short * G4GMocrenIO::getModalityImage(int _z) {
3391
3392 return kModality.getImage(_z);
3393}
3394void G4GMocrenIO::clearModalityImage() {
3395
3396 kModality.clearImage();
3397}
3398// set/get the modality image density map
3399void G4GMocrenIO::setModalityImageDensityMap(std::vector<float> & _map) {
3400 kModalityImageDensityMap = _map;
3401}
3402std::vector<float> & G4GMocrenIO::getModalityImageDensityMap() {
3403 return kModalityImageDensityMap;
3404}
3405// set the modality image min./max.
3406void G4GMocrenIO::setModalityImageMinMax(short _minmax[2]) {
3407
3408 kModality.setMinMax(_minmax);
3409}
3410// get the modality image min./max.
3411void G4GMocrenIO::getModalityImageMinMax(short _minmax[2]) {
3412
3413 short minmax[2];
3414 kModality.getMinMax(minmax);
3415 for(int i = 0; i < 2; i++) _minmax[i] = minmax[i];
3416}
3417short G4GMocrenIO::getModalityImageMax() {
3418
3419 short minmax[2];
3420 kModality.getMinMax(minmax);
3421 return minmax[1];
3422}
3423short G4GMocrenIO::getModalityImageMin() {
3424
3425 short minmax[2];
3426 kModality.getMinMax(minmax);
3427 return minmax[0];
3428}
3429// set/get position of the modality image center
3430void G4GMocrenIO::setModalityCenterPosition(float _center[3]) {
3431
3432 kModality.setCenterPosition(_center);
3433}
3434void G4GMocrenIO::getModalityCenterPosition(float _center[3]) {
3435
3436 if(isROIEmpty())
3437 for(int i = 0; i < 3; i++) _center[i] = 0;
3438 else
3439 kModality.getCenterPosition(_center);
3440}
3441// get & set the modality image unit
3442std::string G4GMocrenIO::getModalityImageUnit() {
3443 return kModalityUnit;
3444}
3445void G4GMocrenIO::setModalityImageUnit(std::string & _unit) {
3446 kModalityUnit = _unit;
3447}
3448//
3449short G4GMocrenIO::convertDensityToHU(float & _dens) {
3450 short rval = -1024; // default: air
3451 int nmap = (int)kModalityImageDensityMap.size();
3452 if(nmap != 0) {
3453 short minmax[2];
3454 kModality.getMinMax(minmax);
3455 rval = minmax[1];
3456 for(int i = 0; i < nmap; i++) {
3457 //G4cout << kModalityImageDensityMap[i] << G4endl;
3458 if(_dens <= kModalityImageDensityMap[i]) {
3459 rval = i + minmax[0];
3460 break;
3461 }
3462 }
3463 }
3464 return rval;
3465}
3466
3467
3468//----- Dose distribution -----//
3469//
3470void G4GMocrenIO::newDoseDist() {
3471 GMocrenDataPrimitive<double> doseData;
3472 kDose.push_back(doseData);
3473}
3474int G4GMocrenIO::getNumDoseDist() {
3475 return (int)kDose.size();
3476}
3477
3478// get & set the dose distribution unit
3479std::string G4GMocrenIO::getDoseDistUnit(int _num) {
3480 // to avoid a warning in the compile process
3481 if(kDoseUnit.size() > static_cast<size_t>(_num)) return kDoseUnit;
3482
3483 return kDoseUnit;
3484}
3485void G4GMocrenIO::setDoseDistUnit(std::string & _unit, int _num) {
3486 // to avoid a warning in the compile process
3487 if(_unit.size() > static_cast<size_t>(_num)) kDoseUnit = _unit;
3488
3489 //char unit[13];
3490 //std::strncpy(unit, _unit.c_str(), 12);
3491 //doseUnit = unit;
3492 kDoseUnit = _unit;
3493}
3494//
3495void G4GMocrenIO::getDoseDistSize(int _size[3], int _num) {
3496 if(isDoseEmpty())
3497 for(int i = 0; i < 3; i++) _size[i] = 0;
3498 else
3499 kDose[_num].getSize(_size);
3500}
3501void G4GMocrenIO::setDoseDistSize(int _size[3], int _num) {
3502
3503 kDose[_num].setSize(_size);
3504
3505 //resetDose();
3506}
3507
3508void G4GMocrenIO::setDoseDistMinMax(short _minmax[2], int _num) {
3509
3510 double minmax[2];
3511 double scale = kDose[_num].getScale();
3512 for(int i = 0; i < 2; i++) minmax[i] = (double)_minmax[i]*scale;
3513 kDose[_num].setMinMax(minmax);
3514}
3515void G4GMocrenIO::getDoseDistMinMax(short _minmax[2], int _num) {
3516
3517 if(isDoseEmpty())
3518 for(int i = 0; i < 2; i++) _minmax[i] = 0;
3519 else {
3520 double minmax[2];
3521 kDose[_num].getMinMax(minmax);
3522 double scale = kDose[_num].getScale();
3523 for(int i = 0; i < 2; i++) _minmax[i] = (short)(minmax[i]/scale+0.5);
3524 }
3525}
3526void G4GMocrenIO::setDoseDistMinMax(double _minmax[2], int _num) {
3527
3528 kDose[_num].setMinMax(_minmax);
3529}
3530void G4GMocrenIO::getDoseDistMinMax(double _minmax[2], int _num) {
3531
3532 if(isDoseEmpty())
3533 for(int i = 0; i < 2; i++) _minmax[i] = 0.;
3534 else
3535 kDose[_num].getMinMax(_minmax);
3536}
3537
3538// get & set the dose distribution image scale
3539void G4GMocrenIO::setDoseDistScale(double & _scale, int _num) {
3540
3541 kDose[_num].setScale(_scale);
3542}
3543double G4GMocrenIO::getDoseDistScale(int _num) {
3544
3545 if(isDoseEmpty())
3546 return 0.;
3547 else
3548 return kDose[_num].getScale();
3549}
3550
3551/*
3552 void G4GMocrenIO::initializeShortDoseDist() {
3553 ;
3554 }
3555 void G4GMocrenIO::finalizeShortDoseDist() {
3556 ;
3557 }
3558*/
3559// set the dose distribution image
3560void G4GMocrenIO::setShortDoseDist(short * _image, int _num) {
3561
3562 int size[3];
3563 kDose[_num].getSize(size);
3564 int dsize = size[0]*size[1];
3565 double * ddata = new double[dsize];
3566 double scale = kDose[_num].getScale();
3567 double minmax[2];
3568 kDose[_num].getMinMax(minmax);
3569 for(int xy = 0; xy < dsize; xy++) {
3570 ddata[xy] = _image[xy]*scale;
3571 if(ddata[xy] < minmax[0]) minmax[0] = ddata[xy];
3572 if(ddata[xy] > minmax[1]) minmax[1] = ddata[xy];
3573 }
3574 kDose[_num].addImage(ddata);
3575
3576 // set min./max.
3577 kDose[_num].setMinMax(minmax);
3578}
3579void G4GMocrenIO::getShortDoseDist(short * _data, int _z, int _num) {
3580
3581 if(_data == NULL) {
3582 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3583 G4cout << "In G4GMocrenIO::getShortDoseDist(), "
3584 << "first argument is NULL pointer. "
3585 << "The argument must be allocated array."
3586 << G4endl;
3587 std::exit(-1);
3588 }
3589
3590 int size[3];
3591 kDose[_num].getSize(size);
3592 //short * shdata = new short[size[0]*size[1]];
3593 double * ddata = kDose[_num].getImage(_z);
3594 double scale = kDose[_num].getScale();
3595 for(int xy = 0; xy < size[0]*size[1]; xy++) {
3596 _data[xy] = (short)(ddata[xy]/scale+0.5); //there is never negative value
3597 }
3598}
3599void G4GMocrenIO::getShortDoseDistMinMax(short _minmax[2], int _num) {
3600 double scale = kDose[_num].getScale();
3601 double minmax[2];
3602 kDose[_num].getMinMax(minmax);
3603 for(int i = 0; i < 2; i++)
3604 _minmax[i] = (short)(minmax[i]/scale+0.5);
3605}
3606//
3607void G4GMocrenIO::setDoseDist(double * _image, int _num) {
3608
3609 kDose[_num].addImage(_image);
3610}
3611double * G4GMocrenIO::getDoseDist(int _z, int _num) {
3612
3613 double * image;
3614 if(isDoseEmpty()) {
3615 image = 0;
3616 } else {
3617 image = kDose[_num].getImage(_z);
3618 }
3619 return image;
3620}
3621/*
3622 void G4GMocrenIO::getDoseDist(double * & _image, int _z, int _num) {
3623
3624 G4cout << " <" << (void*)_image << "> ";
3625 if(isDoseEmpty()) {
3626 _image = 0;
3627 } else {
3628 _image = kDose[_num].getImage(_z);
3629 G4cout << " <" << (void*)_image << "> ";
3630 G4cout << _image[100] << " ";
3631 }
3632 }
3633*/
3634bool G4GMocrenIO::addDoseDist(std::vector<double *> & _image, int _num) {
3635
3636 int size[3];
3637 getDoseDistSize(size, _num);
3638 std::vector<double *> dosedist = kDose[_num].getImage();
3639
3640 int nimg = size[0]*size[1];
3641 for(int z = 0; z < size[2]; z++) {
3642 for(int xy = 0; xy < nimg; xy++) {
3643 dosedist[z][xy] += _image[z][xy];
3644 }
3645 }
3646
3647 return true;
3648}
3649//void setDoseDistDensityMap(float * _map) {doseImageDensityMap = _map;};
3650// set the dose distribution image displacement
3651void G4GMocrenIO::setDoseDistCenterPosition(float _center[3], int _num) {
3652
3653 kDose[_num].setCenterPosition(_center);
3654}
3655void G4GMocrenIO::getDoseDistCenterPosition(float _center[3], int _num) {
3656
3657 if(isDoseEmpty())
3658 for(int i = 0; i < 3; i++) _center[i] = 0;
3659 else
3660 kDose[_num].getCenterPosition(_center);
3661}
3662// set & get name of dose distribution
3663void G4GMocrenIO::setDoseDistName(std::string _name, int _num) {
3664
3665 kDose[_num].setName(_name);
3666}
3667std::string G4GMocrenIO::getDoseDistName(int _num) {
3668
3669 std::string name;
3670 if(isDoseEmpty())
3671 return name;
3672 else
3673 return kDose[_num].getName();
3674}
3675// copy dose distributions
3676void G4GMocrenIO::copyDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose) {
3677 std::vector<class GMocrenDataPrimitive<double> >::iterator itr;
3678 for(itr = kDose.begin(); itr != kDose.end(); itr++) {
3679 _dose.push_back(*itr);
3680 }
3681}
3682// merge two dose distributions
3683bool G4GMocrenIO::mergeDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose) {
3684 if(kDose.size() != _dose.size()) {
3685 if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
3686 G4cout << "G4GMocrenIO::mergeDoseDist() : Error" << G4endl;
3687 G4cout << " Unable to merge the dose distributions,"<< G4endl;
3688 G4cout << " because of different size of dose maps."<< G4endl;
3689 }
3690 return false;
3691 }
3692
3693 int num = kDose.size();
3694 std::vector<class GMocrenDataPrimitive<double> >::iterator itr1 = kDose.begin();
3695 std::vector<class GMocrenDataPrimitive<double> >::iterator itr2 = _dose.begin();
3696 for(int i = 0; i < num; i++, itr1++, itr2++) {
3697 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3698 if(kVerbose > 0)
3699 G4cout << "merged dose distribution [" << i << "]" << G4endl;
3700 *itr1 += *itr2;
3701 }
3702
3703 return true;
3704}
3705//
3706void G4GMocrenIO::clearDoseDistAll() {
3707
3708 if(!isDoseEmpty()) {
3709 for(int i = 0; i < getNumDoseDist(); i++) {
3710 kDose[i].clear();
3711 }
3712 kDose.clear();
3713 }
3714}
3715//
3716bool G4GMocrenIO::isDoseEmpty() {
3717 if(kDose.empty()) {
3718 //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3719 // G4cout << "!!! dose distribution data is empty." << G4endl;
3720 return true;
3721 } else {
3722 return false;
3723 }
3724}
3725
3726//
3727void G4GMocrenIO::calcDoseDistScale() {
3728
3729 double scale;
3730 double minmax[2];
3731
3732 for(int i = 0; i < (int)kDose.size(); i++) {
3733 kDose[i].getMinMax(minmax);
3734 scale = minmax[1]/DOSERANGE;
3735 kDose[i].setScale(scale);
3736 }
3737}
3738
3739
3740//----- RoI -----//
3741
3742// add one RoI data
3743void G4GMocrenIO::newROI() {
3744 GMocrenDataPrimitive<short> roiData;
3745 kRoi.push_back(roiData);
3746}
3747int G4GMocrenIO::getNumROI() {
3748 return (int)kRoi.size();
3749}
3750
3751// set/get the ROI image scale
3752void G4GMocrenIO::setROIScale(double & _scale, int _num) {
3753
3754 kRoi[_num].setScale(_scale);
3755}
3756double G4GMocrenIO::getROIScale(int _num) {
3757
3758 if(isROIEmpty())
3759 return 0.;
3760 else
3761 return kRoi[_num].getScale();
3762}
3763// set the ROI image
3764void G4GMocrenIO::setROI(short * _image, int _num) {
3765
3766 kRoi[_num].addImage(_image);
3767}
3768short * G4GMocrenIO::getROI(int _z, int _num) {
3769
3770 if(isROIEmpty())
3771 return 0;
3772 else
3773 return kRoi[_num].getImage(_z);
3774}
3775// set/get the ROI image size
3776void G4GMocrenIO::setROISize(int _size[3], int _num) {
3777
3778 return kRoi[_num].setSize(_size);
3779}
3780void G4GMocrenIO::getROISize(int _size[3], int _num) {
3781
3782 if(isROIEmpty())
3783 for(int i = 0; i < 3; i++) _size[i] = 0;
3784 else
3785 return kRoi[_num].getSize(_size);
3786}
3787// set/get the ROI image min. and max.
3788void G4GMocrenIO::setROIMinMax(short _minmax[2], int _num) {
3789
3790 kRoi[_num].setMinMax(_minmax);
3791}
3792void G4GMocrenIO::getROIMinMax(short _minmax[2], int _num) {
3793
3794 if(isROIEmpty())
3795 for(int i = 0; i < 2; i++) _minmax[i] = 0;
3796 else
3797 kRoi[_num].getMinMax(_minmax);
3798}
3799// set/get the ROI image displacement
3800void G4GMocrenIO::setROICenterPosition(float _center[3], int _num) {
3801
3802 kRoi[_num].setCenterPosition(_center);
3803}
3804void G4GMocrenIO::getROICenterPosition(float _center[3], int _num) {
3805
3806 if(isROIEmpty())
3807 for(int i = 0; i < 3; i++) _center[i] = 0;
3808 else
3809 kRoi[_num].getCenterPosition(_center);
3810}
3811//
3812void G4GMocrenIO::clearROIAll() {
3813
3814 if(!isROIEmpty()) {
3815 for(int i = 0; i < getNumROI(); i++) {
3816 kRoi[i].clear();
3817 }
3818 kRoi.clear();
3819 }
3820}
3821//
3822bool G4GMocrenIO::isROIEmpty() {
3823 if(kRoi.empty()) {
3824 //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3825 // G4cout << "!!! ROI data is empty." << G4endl;
3826 return true;
3827 } else {
3828 return false;
3829 }
3830}
3831
3832
3833
3834//----- Track information -----//
3835
3836int G4GMocrenIO::getNumTracks() {
3837 return (int)kSteps.size();
3838}
3839int G4GMocrenIO::getNumTracks4() {
3840 return (int)kTracks.size();
3841}
3842void G4GMocrenIO::addTrack(float * _tracks) {
3843 kSteps.push_back(_tracks);
3844}
3845void G4GMocrenIO::setTracks(std::vector<float *> & _tracks) {
3846 kSteps = _tracks;
3847}
3848std::vector<float *> & G4GMocrenIO::getTracks() {
3849 return kSteps;
3850}
3851void G4GMocrenIO::addTrackColor(unsigned char * _colors) {
3852 kStepColors.push_back(_colors);
3853}
3854void G4GMocrenIO::setTrackColors(std::vector<unsigned char *> & _trackColors) {
3855 kStepColors = _trackColors;
3856}
3857std::vector<unsigned char *> & G4GMocrenIO::getTrackColors() {
3858 return kStepColors;
3859}
3860void G4GMocrenIO::copyTracks(std::vector<float *> & _tracks,
3861 std::vector<unsigned char *> & _colors) {
3862 std::vector<float *>::iterator titr;
3863 for(titr = kSteps.begin(); titr != kSteps.end(); titr++) {
3864 float * pts = new float[6];
3865 for(int i = 0; i < 6; i++) {
3866 pts[i] = (*titr)[i];
3867 }
3868 _tracks.push_back(pts);
3869 }
3870
3871 std::vector<unsigned char *>::iterator citr;
3872 for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++) {
3873 unsigned char * pts = new unsigned char[3];
3874 for(int i = 0; i < 3; i++) {
3875 pts[i] = (*citr)[i];
3876 }
3877 _colors.push_back(pts);
3878 }
3879}
3880void G4GMocrenIO::mergeTracks(std::vector<float *> & _tracks,
3881 std::vector<unsigned char *> & _colors) {
3882 std::vector<float *>::iterator titr;
3883 for(titr = _tracks.begin(); titr != _tracks.end(); titr++) {
3884 addTrack(*titr);
3885 }
3886
3887 std::vector<unsigned char *>::iterator citr;
3888 for(citr = _colors.begin(); citr != _colors.end(); citr++) {
3889 addTrackColor(*citr);
3890 }
3891}
3892void G4GMocrenIO::addTrack(std::vector<float *> & _steps, unsigned char _color[3]) {
3893
3894 std::vector<float *>::iterator itr = _steps.begin();
3895 std::vector<struct GMocrenTrack::Step> steps;
3896 for(; itr != _steps.end(); itr++) {
3897 struct GMocrenTrack::Step step;
3898 for(int i = 0; i < 3; i++) {
3899 step.startPoint[i] = (*itr)[i];
3900 step.endPoint[i] = (*itr)[i+3];
3901 }
3902 steps.push_back(step);
3903 }
3904 GMocrenTrack track;
3905 track.setTrack(steps);
3906 track.setColor(_color);
3907 kTracks.push_back(track);
3908
3909}
3910void G4GMocrenIO::getTrack(int _num, std::vector<float *> & _steps,
3911 std::vector<unsigned char *> & _color) {
3912
3913 if(_num > (int)kTracks.size()) {
3914 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3915 G4cout << "ERROR in getTrack() : " << G4endl;
3916 std::exit(-1);
3917 }
3918 unsigned char * color = new unsigned char[3];
3919 kTracks[_num].getColor(color);
3920 _color.push_back(color);
3921
3922 // steps
3923 int nsteps = kTracks[_num].getNumberOfSteps();
3924 for(int isteps = 0; isteps < nsteps; isteps++) {
3925 float * stepPoints = new float[6];
3926 kTracks[_num].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
3927 stepPoints[3], stepPoints[4], stepPoints[5],
3928 isteps);
3929 _steps.push_back(stepPoints);
3930 }
3931}
3932
3933void G4GMocrenIO::translateTracks(std::vector<float> & _translate) {
3934 std::vector<class GMocrenTrack>::iterator itr = kTracks.begin();
3935 for(; itr != kTracks.end(); itr++) {
3936 itr->translate(_translate);
3937 }
3938}
3939
3940
3941
3942
3943//----- Detector information -----//
3944int G4GMocrenIO::getNumberOfDetectors() {
3945 return (int)kDetectors.size();
3946}
3947void G4GMocrenIO::addDetector(std::string & _name,
3948 std::vector<float *> & _det,
3949 unsigned char _color[3]) {
3950
3951 std::vector<float *>::iterator itr = _det.begin();
3952 std::vector<struct GMocrenDetector::Edge> edges;
3953 for(; itr != _det.end(); itr++) {
3954 struct GMocrenDetector::Edge edge;
3955 for(int i = 0; i < 3; i++) {
3956 edge.startPoint[i] = (*itr)[i];
3957 edge.endPoint[i] = (*itr)[i+3];
3958 }
3959 edges.push_back(edge);
3960 }
3961 GMocrenDetector detector;
3962 detector.setDetector(edges);
3963 detector.setColor(_color);
3964 detector.setName(_name);
3965 kDetectors.push_back(detector);
3966
3967}
3968
3969void G4GMocrenIO::getDetector(int _num, std::vector<float *> & _edges,
3970 std::vector<unsigned char *> & _color,
3971 std::string & _detName) {
3972
3973 if(_num > (int)kDetectors.size()) {
3974 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3975 G4cout << "ERROR in getDetector() : " << G4endl;
3976 std::exit(-1);
3977 }
3978
3979 _detName = kDetectors[_num].getName();
3980
3981 unsigned char * color = new unsigned char[3];
3982 kDetectors[_num].getColor(color);
3983 _color.push_back(color);
3984
3985 // edges
3986 int nedges = kDetectors[_num].getNumberOfEdges();
3987 for(int ne = 0; ne < nedges; ne++) {
3988 float * edgePoints = new float[6];
3989 kDetectors[_num].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
3990 edgePoints[3], edgePoints[4], edgePoints[5],
3991 ne);
3992 _edges.push_back(edgePoints);
3993 }
3994}
3995
3996void G4GMocrenIO::translateDetector(std::vector<float> & _translate) {
3997 std::vector<class GMocrenDetector>::iterator itr = kDetectors.begin();
3998 for(; itr != kDetectors.end(); itr++) {
3999 itr->translate(_translate);
4000 }
4001}
4002
4003// endian conversion
4004template <typename T>
4005void G4GMocrenIO::convertEndian(char * _val, T & _rval) {
4006
4007 if((kLittleEndianOutput && !kLittleEndianInput) || // big endian
4008 (!kLittleEndianOutput && kLittleEndianInput)) { // little endian
4009
4010 const int SIZE = sizeof(_rval);
4011 char ctemp;
4012 for(int i = 0; i < SIZE/2; i++) {
4013 ctemp = _val[i];
4014 _val[i] = _val[SIZE - 1 - i];
4015 _val[SIZE - 1 - i] = ctemp;
4016 }
4017 }
4018 _rval = *(T *)_val;
4019}
4020
4021// inversion of byte order
4022template <typename T>
4023void G4GMocrenIO::invertByteOrder(char * _val, T & _rval) {
4024
4025 const int SIZE = sizeof(_rval);
4026 //char * cval = new char[SIZE];
4027 union {
4028 char cu[16];
4029 T tu;
4030 } uni;
4031 for(int i = 0; i < SIZE; i++) {
4032 uni.cu[i] = _val[SIZE-1-i];
4033 //cval[i] = _val[SIZE-i-1];
4034 }
4035 //_rval = *(T *)cval;
4036 _rval = uni.tu;
4037 //delete [] cval;
4038}
4039
4040//----- kVerbose information -----//
4041void G4GMocrenIO::setVerboseLevel(int _level) {
4042 kVerbose = _level;
4043}
4044
IDLENGTH
const int IDLENGTH
Definition: G4GMocrenIO.cc:397
VERLENGTH
const int VERLENGTH
Definition: G4GMocrenIO.cc:398
DOSERANGE
const int DOSERANGE
Definition: G4GMocrenIO.cc:56
DEBUG
#define DEBUG(x)
Definition: G4INCLLogger.hh:235
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
G4GMocrenIO::setTracks
void setTracks(std::vector< float * > &_tracks)
Definition: G4GMocrenIO.cc:3845
G4GMocrenIO::setLittleEndianInput
void setLittleEndianInput(bool _little)
Definition: G4GMocrenIO.cc:3128
G4GMocrenIO::setModalityImageSize
void setModalityImageSize(int _size[3])
Definition: G4GMocrenIO.cc:3370
G4GMocrenIO::setDoseDistUnit
void setDoseDistUnit(std::string &_unit, int _num=0)
Definition: G4GMocrenIO.cc:3485
G4GMocrenIO::convertDensityToHU
short convertDensityToHU(float &_dens)
Definition: G4GMocrenIO.cc:3449
G4GMocrenIO::copyDoseDist
void copyDoseDist(std::vector< class GMocrenDataPrimitive< double > > &_dose)
Definition: G4GMocrenIO.cc:3676
G4GMocrenIO::getPointerToTrackData
unsigned int getPointerToTrackData()
Definition: G4GMocrenIO.cc:3180
G4GMocrenIO::setDoseDistMinMax
void setDoseDistMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3508
G4GMocrenIO::kVerbose
static int kVerbose
Definition: G4GMocrenIO.hh:225
G4GMocrenIO::setDoseDistScale
void setDoseDistScale(double &_scale, int _num=0)
Definition: G4GMocrenIO.cc:3539
G4GMocrenIO::getShortDoseDist
void getShortDoseDist(short *_data, int _z, int _num=0)
Definition: G4GMocrenIO.cc:3579
G4GMocrenIO::kLittleEndianOutput
static char kLittleEndianOutput
Definition: G4GMocrenIO.hh:179
G4GMocrenIO::clearModalityImage
void clearModalityImage()
Definition: G4GMocrenIO.cc:3394
G4GMocrenIO::setVerboseLevel
void setVerboseLevel(int _level)
Definition: G4GMocrenIO.cc:4041
G4GMocrenIO::setROISize
void setROISize(int _size[3], int _num=0)
Definition: G4GMocrenIO.cc:3776
G4GMocrenIO::setModalityImageDensityMap
void setModalityImageDensityMap(std::vector< float > &_map)
Definition: G4GMocrenIO.cc:3399
G4GMocrenIO::getNumDoseDist
int getNumDoseDist()
Definition: G4GMocrenIO.cc:3474
G4GMocrenIO::translateDetector
void translateDetector(std::vector< float > &_translate)
Definition: G4GMocrenIO.cc:3996
G4GMocrenIO::setDoseDistCenterPosition
void setDoseDistCenterPosition(float _center[3], int _num=0)
Definition: G4GMocrenIO.cc:3651
G4GMocrenIO::getROISize
void getROISize(int _size[3], int _num=0)
Definition: G4GMocrenIO.cc:3780
G4GMocrenIO::setPointerToROIData
void setPointerToROIData(unsigned int &_pointer)
Definition: G4GMocrenIO.cc:3170
G4GMocrenIO::getROICenterPosition
void getROICenterPosition(float _center[3], int _num=0)
Definition: G4GMocrenIO.cc:3804
G4GMocrenIO::kPointerToDoseDistData
static std::vector< unsigned int > kPointerToDoseDistData
Definition: G4GMocrenIO.hh:189
G4GMocrenIO::setNumberOfEvents
void setNumberOfEvents(int &_numberOfEvents)
Definition: G4GMocrenIO.cc:3143
G4GMocrenIO::storeData3
bool storeData3()
Definition: G4GMocrenIO.cc:1039
G4GMocrenIO::retrieveData
bool retrieveData()
Definition: G4GMocrenIO.cc:1601
G4GMocrenIO::kTracksWillBeStored
bool kTracksWillBeStored
Definition: G4GMocrenIO.hh:219
G4GMocrenIO::getModalityImageDensityMap
std::vector< float > & getModalityImageDensityMap()
Definition: G4GMocrenIO.cc:3402
G4GMocrenIO::getDoseDistName
std::string getDoseDistName(int _num=0)
Definition: G4GMocrenIO.cc:3667
G4GMocrenIO::kPointerToModalityData
static unsigned int kPointerToModalityData
Definition: G4GMocrenIO.hh:187
G4GMocrenIO::getModalityImageUnit
std::string getModalityImageUnit()
Definition: G4GMocrenIO.cc:3442
G4GMocrenIO::setComment
void setComment(std::string &_comment)
Definition: G4GMocrenIO.hh:275
G4GMocrenIO::clearROIAll
void clearROIAll()
Definition: G4GMocrenIO.cc:3812
G4GMocrenIO::getROIScale
double getROIScale(int _num=0)
Definition: G4GMocrenIO.cc:3756
G4GMocrenIO::setVoxelSpacing
void setVoxelSpacing(float _spacing[3])
Definition: G4GMocrenIO.cc:3132
G4GMocrenIO::getPointerToROIData
unsigned int getPointerToROIData()
Definition: G4GMocrenIO.cc:3173
G4GMocrenIO::setDoseDistName
void setDoseDistName(std::string _name, int _num=0)
Definition: G4GMocrenIO.cc:3663
G4GMocrenIO::kSteps
static std::vector< float * > kSteps
Definition: G4GMocrenIO.hh:215
G4GMocrenIO::getTrackColors
std::vector< unsigned char * > & getTrackColors()
Definition: G4GMocrenIO.cc:3857
G4GMocrenIO::kModalityImageDensityMap
static std::vector< float > kModalityImageDensityMap
Definition: G4GMocrenIO.hh:203
G4GMocrenIO::getModalityImageScale
double getModalityImageScale()
Definition: G4GMocrenIO.cc:3380
G4GMocrenIO::isROIEmpty
bool isROIEmpty()
Definition: G4GMocrenIO.cc:3822
G4GMocrenIO::getVoxelSpacing
void getVoxelSpacing(float _spacing[3])
Definition: G4GMocrenIO.cc:3135
G4GMocrenIO::storeData2
bool storeData2()
Definition: G4GMocrenIO.cc:1338
G4GMocrenIO::mergeDoseDist
bool mergeDoseDist(std::vector< class GMocrenDataPrimitive< double > > &_dose)
Definition: G4GMocrenIO.cc:3683
G4GMocrenIO::setModalityImage
void setModalityImage(short *_image)
Definition: G4GMocrenIO.cc:3386
G4GMocrenIO::getPointerToModalityData
unsigned int getPointerToModalityData()
Definition: G4GMocrenIO.cc:3154
G4GMocrenIO::convertEndian
void convertEndian(char *, Type &)
G4GMocrenIO::setTrackColors
void setTrackColors(std::vector< unsigned char * > &_trackColors)
Definition: G4GMocrenIO.cc:3854
G4GMocrenIO::setVersion
void setVersion(std::string &_version)
Definition: G4GMocrenIO.cc:3125
G4GMocrenIO::getModalityImageMinMax
void getModalityImageMinMax(short _minmax[2])
Definition: G4GMocrenIO.cc:3411
G4GMocrenIO::getModalityCenterPosition
void getModalityCenterPosition(float _center[3])
Definition: G4GMocrenIO.cc:3434
G4GMocrenIO::setModalityCenterPosition
void setModalityCenterPosition(float _center[3])
Definition: G4GMocrenIO.cc:3430
G4GMocrenIO::getDoseDistScale
double getDoseDistScale(int _num=0)
Definition: G4GMocrenIO.cc:3543
G4GMocrenIO::getModalityImageMax
short getModalityImageMax()
Definition: G4GMocrenIO.cc:3417
G4GMocrenIO::getTracks
std::vector< float * > & getTracks()
Definition: G4GMocrenIO.cc:3848
G4GMocrenIO::setPointerToTrackData
void setPointerToTrackData(unsigned int &_pointer)
Definition: G4GMocrenIO.cc:3177
G4GMocrenIO::setDoseDistSize
void setDoseDistSize(int _size[3], int _num=0)
Definition: G4GMocrenIO.cc:3501
G4GMocrenIO::kNumberOfEvents
static int kNumberOfEvents
Definition: G4GMocrenIO.hh:184
G4GMocrenIO::getNumTracks
int getNumTracks()
Definition: G4GMocrenIO.cc:3836
G4GMocrenIO::kDose
static std::vector< class GMocrenDataPrimitive< double > > kDose
Definition: G4GMocrenIO.hh:207
G4GMocrenIO::getDoseDistMinMax
void getDoseDistMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3515
G4GMocrenIO::setModalityImageUnit
void setModalityImageUnit(std::string &_unit)
Definition: G4GMocrenIO.cc:3445
G4GMocrenIO::setModalityImageMinMax
void setModalityImageMinMax(short _minmax[2])
Definition: G4GMocrenIO.cc:3406
G4GMocrenIO::kPointerToROIData
static unsigned int kPointerToROIData
Definition: G4GMocrenIO.hh:191
G4GMocrenIO::setROIMinMax
void setROIMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3788
G4GMocrenIO::getTrack
void getTrack(int _num, std::vector< float * > &_steps, std::vector< unsigned char * > &_color)
Definition: G4GMocrenIO.cc:3910
G4GMocrenIO::setPointerToModalityData
void setPointerToModalityData(unsigned int &_pointer)
Definition: G4GMocrenIO.cc:3151
G4GMocrenIO::addDoseDist
bool addDoseDist(std::vector< double * > &_image, int _num=0)
Definition: G4GMocrenIO.cc:3634
G4GMocrenIO::getPointerToDoseDistData
unsigned int getPointerToDoseDistData(int _elem=0)
Definition: G4GMocrenIO.cc:3161
G4GMocrenIO::storeData4
bool storeData4()
Definition: G4GMocrenIO.cc:461
G4GMocrenIO::setShortDoseDist
void setShortDoseDist(short *_image, int _num=0)
Definition: G4GMocrenIO.cc:3560
G4GMocrenIO::storeData
bool storeData()
Definition: G4GMocrenIO.cc:453
G4GMocrenIO::kPointerToDetectorData
static unsigned int kPointerToDetectorData
Definition: G4GMocrenIO.hh:195
G4GMocrenIO::getDoseDistSize
void getDoseDistSize(int _size[3], int _num=0)
Definition: G4GMocrenIO.cc:3495
G4GMocrenIO::addPointerToDoseDistData
void addPointerToDoseDistData(unsigned int &_pointer)
Definition: G4GMocrenIO.cc:3158
G4GMocrenIO::kRoi
static std::vector< class GMocrenDataPrimitive< short > > kRoi
Definition: G4GMocrenIO.hh:212
G4GMocrenIO::newDoseDist
void newDoseDist()
Definition: G4GMocrenIO.cc:3470
G4GMocrenIO::retrieveData3
bool retrieveData3()
Definition: G4GMocrenIO.cc:2189
G4GMocrenIO::getNumTracks4
int getNumTracks4()
Definition: G4GMocrenIO.cc:3839
G4GMocrenIO::kTracks
static std::vector< class GMocrenTrack > kTracks
Definition: G4GMocrenIO.hh:218
G4GMocrenIO::kPointerToTrackData
static unsigned int kPointerToTrackData
Definition: G4GMocrenIO.hh:193
G4GMocrenIO::getModalityImage
short * getModalityImage(int _z)
Definition: G4GMocrenIO.cc:3390
G4GMocrenIO::clearDoseDistAll
void clearDoseDistAll()
Definition: G4GMocrenIO.cc:3706
G4GMocrenIO::retrieveData4
bool retrieveData4()
Definition: G4GMocrenIO.cc:1656
G4GMocrenIO::mergeTracks
void mergeTracks(std::vector< float * > &_tracks, std::vector< unsigned char * > &_colors)
Definition: G4GMocrenIO.cc:3880
G4GMocrenIO::kVersion
static std::string kVersion
Definition: G4GMocrenIO.hh:172
G4GMocrenIO::setROICenterPosition
void setROICenterPosition(float _center[3], int _num=0)
Definition: G4GMocrenIO.cc:3800
G4GMocrenIO::getNumberOfEvents
int & getNumberOfEvents()
Definition: G4GMocrenIO.cc:3140
G4GMocrenIO::kVoxelSpacing
static float kVoxelSpacing[3]
Definition: G4GMocrenIO.hh:198
G4GMocrenIO::initialize
void initialize()
Definition: G4GMocrenIO.cc:412
G4GMocrenIO::setLittleEndianOutput
void setLittleEndianOutput(bool _little)
Definition: G4GMocrenIO.cc:3129
G4GMocrenIO::getVersion
std::string & getVersion()
Definition: G4GMocrenIO.cc:3124
G4GMocrenIO::kStepColors
static std::vector< unsigned char * > kStepColors
Definition: G4GMocrenIO.hh:216
G4GMocrenIO::kDetectors
static std::vector< class GMocrenDetector > kDetectors
Definition: G4GMocrenIO.hh:222
G4GMocrenIO::getDoseDistUnit
std::string getDoseDistUnit(int _num=0)
Definition: G4GMocrenIO.cc:3479
G4GMocrenIO::calcDoseDistScale
void calcDoseDistScale()
Definition: G4GMocrenIO.cc:3727
G4GMocrenIO::kLittleEndianInput
static char kLittleEndianInput
Definition: G4GMocrenIO.hh:178
G4GMocrenIO::copyTracks
void copyTracks(std::vector< float * > &_tracks, std::vector< unsigned char * > &_colors)
Definition: G4GMocrenIO.cc:3860
G4GMocrenIO::isDoseEmpty
bool isDoseEmpty()
Definition: G4GMocrenIO.cc:3716
G4GMocrenIO::addDetector
void addDetector(std::string &_name, std::vector< float * > &_det, unsigned char _color[3])
Definition: G4GMocrenIO.cc:3947
G4GMocrenIO::getDoseDistCenterPosition
void getDoseDistCenterPosition(float _center[3], int _num=0)
Definition: G4GMocrenIO.cc:3655
G4GMocrenIO::getROIMinMax
void getROIMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3792
G4GMocrenIO::getModalityImageMin
short getModalityImageMin()
Definition: G4GMocrenIO.cc:3423
G4GMocrenIO::getModalityImageSize
void getModalityImageSize(int _size[3])
Definition: G4GMocrenIO.cc:3366
G4GMocrenIO::getNumberOfDetectors
int getNumberOfDetectors()
Definition: G4GMocrenIO.cc:3944
G4GMocrenIO::addTrackColor
void addTrackColor(unsigned char *_colors)
Definition: G4GMocrenIO.cc:3851
G4GMocrenIO::setROI
void setROI(short *_image, int _num=0)
Definition: G4GMocrenIO.cc:3764
G4GMocrenIO::kDoseUnit
static std::string kDoseUnit
Definition: G4GMocrenIO.hh:209
G4GMocrenIO::kComment
static std::string kComment
Definition: G4GMocrenIO.hh:181
G4GMocrenIO::setDoseDist
void setDoseDist(double *_image, int _num=0)
Definition: G4GMocrenIO.cc:3607
G4GMocrenIO::retrieveData2
bool retrieveData2()
Definition: G4GMocrenIO.cc:2627
G4GMocrenIO::translateTracks
void translateTracks(std::vector< float > &_translateo)
Definition: G4GMocrenIO.cc:3933
G4GMocrenIO::invertByteOrder
void invertByteOrder(char *_val, T &_rval)
Definition: G4GMocrenIO.cc:4023
G4GMocrenIO::addTrack
void addTrack(float *_tracks)
Definition: G4GMocrenIO.cc:3842
G4GMocrenIO::kModalityUnit
static std::string kModalityUnit
Definition: G4GMocrenIO.hh:204
G4GMocrenIO::getDetector
void getDetector(int _num, std::vector< float * > &_edges, std::vector< unsigned char * > &_color, std::string &_detectorName)
Definition: G4GMocrenIO.cc:3969
G4GMocrenIO::getROI
short * getROI(int _z, int _num=0)
Definition: G4GMocrenIO.cc:3768
G4GMocrenIO::setModalityImageScale
void setModalityImageScale(double &_scale)
Definition: G4GMocrenIO.cc:3376
G4GMocrenIO::kModality
static class GMocrenDataPrimitive< short > kModality
Definition: G4GMocrenIO.hh:201
G4GMocrenIO::getShortDoseDistMinMax
void getShortDoseDistMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3599
G4GMocrenIO::kId
static std::string kId
Definition: G4GMocrenIO.hh:169
G4GMocrenIO::getDoseDist
double * getDoseDist(int _z, int _num=0)
Definition: G4GMocrenIO.cc:3611
G4GMocrenIO::kFileName
static std::string kFileName
Definition: G4GMocrenIO.hh:175
G4GMocrenIO::addOneEvent
void addOneEvent()
Definition: G4GMocrenIO.cc:3146
G4GMocrenIO::setROIScale
void setROIScale(double &_scale, int _num=0)
Definition: G4GMocrenIO.cc:3752
G4VisManager::GetVerbosity
static Verbosity GetVerbosity()
Definition: G4VisManager.cc:1816
GMocrenDataPrimitive::operator=
GMocrenDataPrimitive< T > & operator=(const GMocrenDataPrimitive< T > &_right)
Definition: G4GMocrenIO.cc:74
GMocrenDataPrimitive::setImage
void setImage(std::vector< T * > &_image)
Definition: G4GMocrenIO.cc:212
GMocrenDataPrimitive::getName
std::string getName()
Definition: G4GMocrenIO.cc:241
GMocrenDataPrimitive::getImage
std::vector< T * > & getImage()
Definition: G4GMocrenIO.cc:220
GMocrenDataPrimitive::setSize
void setSize(int _size[3])
Definition: G4GMocrenIO.cc:187
GMocrenDataPrimitive::getMinMax
void getMinMax(T _minmax[2])
Definition: G4GMocrenIO.cc:207
GMocrenDataPrimitive::operator+=
GMocrenDataPrimitive< T > & operator+=(const GMocrenDataPrimitive< T > &_right)
Definition: G4GMocrenIO.cc:134
GMocrenDataPrimitive::setMinMax
void setMinMax(T _minmax[2])
Definition: G4GMocrenIO.cc:203
GMocrenDataPrimitive::getCenterPosition
void getCenterPosition(float _center[3])
Definition: G4GMocrenIO.cc:233
GMocrenDataPrimitive::setName
void setName(std::string &_name)
Definition: G4GMocrenIO.cc:237
GMocrenDataPrimitive::setCenterPosition
void setCenterPosition(float _center[3])
Definition: G4GMocrenIO.cc:229
GMocrenDataPrimitive::operator+
GMocrenDataPrimitive< T > & operator+(const GMocrenDataPrimitive< T > &_right)
Definition: G4GMocrenIO.cc:92
GMocrenDataPrimitive::getSize
void getSize(int _size[3])
Definition: G4GMocrenIO.cc:191
GMocrenDataPrimitive::setScale
void setScale(double &_scale)
Definition: G4GMocrenIO.cc:195
GMocrenDataPrimitive::kImage
std::vector< T * > kImage
Definition: G4GMocrenIO.hh:56
GMocrenDataPrimitive::addImage
void addImage(T *_image)
Definition: G4GMocrenIO.cc:216
GMocrenDetector::setColor
void setColor(unsigned char _color[3])
Definition: G4GMocrenIO.hh:150
GMocrenDetector::kColor
unsigned char kColor[3]
Definition: G4GMocrenIO.hh:135
GMocrenDetector::setName
void setName(std::string &_name)
Definition: G4GMocrenIO.hh:156
GMocrenDetector::translate
void translate(std::vector< float > &_tranlate)
Definition: G4GMocrenIO.cc:333
GMocrenDetector::addEdge
void addEdge(float _startx, float _starty, float _startz, float _endx, float _endy, float _endz)
Definition: G4GMocrenIO.cc:305
GMocrenDetector::getEdge
void getEdge(float &_startx, float &_starty, float &_startz, float &_endx, float &_endy, float &_endz, int _num)
Definition: G4GMocrenIO.cc:316
GMocrenDetector::kDetector
std::vector< struct Edge > kDetector
Definition: G4GMocrenIO.hh:134
GMocrenDetector::setDetector
void setDetector(std::vector< struct Edge > &_aDetector)
Definition: G4GMocrenIO.hh:149
GMocrenTrack::getStep
void getStep(float &_startx, float &_starty, float &_startz, float &_endx, float &_endy, float &_endz, int _num)
Definition: G4GMocrenIO.cc:265
GMocrenTrack::translate
void translate(std::vector< float > &_tranlate)
Definition: G4GMocrenIO.cc:282
GMocrenTrack::setColor
void setColor(unsigned char _color[3])
Definition: G4GMocrenIO.hh:113
GMocrenTrack::setTrack
void setTrack(std::vector< struct Step > &_aTrack)
Definition: G4GMocrenIO.hh:112
GMocrenTrack::addStep
void addStep(float _startx, float _starty, float _startz, float _endx, float _endy, float _endz)
Definition: G4GMocrenIO.cc:254
GMocrenTrack::kColor
unsigned char kColor[3]
Definition: G4GMocrenIO.hh:99
GMocrenTrack::kTrack
std::vector< struct Step > kTrack
Definition: G4GMocrenIO.hh:98
ofile
std::ofstream ofile
Definition: clparse.cc:45
const
#define const
Definition: zconf.h:118