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