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