]> Creatis software - gdcm.git/blob - Example/Dense2007ToDicom.cxx
comments
[gdcm.git] / Example / Dense2007ToDicom.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: Dense2007ToDicom.cxx,v $
5   Language:  C++
6   Date:      $Date: 2008/03/31 15:05:07 $
7   Version:   $Revision: 1.9 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18
19 #include <fstream>
20 #include <iostream>
21 //#include <values.h>
22
23 #if defined(__BORLANDC__)
24 #include <ctype.h>
25 #endif
26
27 #include "gdcmFile.h"
28 #include "gdcmFileHelper.h"
29 #include "gdcmDebug.h"
30 #include "gdcmDirList.h"
31 #include "gdcmUtil.h"
32 #include "gdcmArgMgr.h"
33
34 /**
35   * \brief   
36   *  Converts the "Dense" ".txt" (2007 version)  files into 16 bits Dicom Files,
37   * Hope they don't change soon!
38   */  
39
40 void LoadPeakStrain(std::ifstream &from, std::string imageName, const char * patientname, std::string studyUID);
41 void LoadStrain(std::ifstream &from, std::string imageName, const char * patientname, bool createMultiFrame, std::string studyUID);
42 void MakeDicomImage(float *tabVal, float *X, float *Y, float *Z, int NP, std::string dcmImageName,
43                     const char * patientname, int nbFrames, std::string studyUID, std::string serieUID);
44
45 bool verbose;
46
47 int main(int argc, char *argv[])
48 {
49    START_USAGE(usage)
50    " \n Dense2007ToDicom :\n                                                  ",
51    "        Converts the '.txt' files into 16 bits Dicom Files,               ",
52    " usage:                                                                   ",
53    " Dense2007ToDicom strain=...strain.txt  peak_strain=...peak_strain.txt    ",
54    "                 [patientname = Patient's name]                           ",
55    "                 [m]ultiframe                                             ",
56    "                 [verbose] [debug]                                        ",
57    "                                                                          ",
58    " verbose  : user wants to run the program in 'verbose mode'               ",
59    " debug    : *developer*  wants to run the program in 'debug mode'         ",
60    FINISH_USAGE
61
62    // ----- Initialize Arguments Manager ------
63       
64    GDCM_NAME_SPACE::ArgMgr *am = new GDCM_NAME_SPACE::ArgMgr(argc, argv);
65   
66    if (argc == 1 || am->ArgMgrDefined("usage")) 
67    {
68       am->ArgMgrUsage(usage); // Display 'usage'
69       delete am;
70       return 0;
71    }
72    // Seems that ArgMgrWantString doesn't work on MacOS   
73    if(!am->ArgMgrDefined("strain"))
74    {
75       std::cout << "strain is mandatory" << std::endl;
76       exit(0);   
77    }
78    if(!am->ArgMgrDefined("peak_strain"))
79    {
80       std::cout << "peak_strain is mandatory" << std::endl;
81       exit(0);   
82    }
83       
84    const char *strain      = am->ArgMgrWantString("strain",usage);
85    const char *peak_strain = am->ArgMgrWantString("peak_strain",usage);
86
87    const char *patientName = am->ArgMgrGetString("patientname", "Patient^Name");
88    
89    bool createMultiFrame = (am->ArgMgrDefined("m") != 0);
90          
91    if (am->ArgMgrDefined("debug"))
92       GDCM_NAME_SPACE::Debug::DebugOn();
93
94    verbose  =  ( 0 != am->ArgMgrDefined("verbose") );     
95
96    // if unused Param we give up
97    if ( am->ArgMgrPrintUnusedLabels() )
98    { 
99       am->ArgMgrUsage(usage);
100       delete am;
101       return 0;
102    }
103    delete am;  // we don't need Argument Manager any longer
104
105    // ----- Begin Processing -----
106
107    std::ifstream fromPeakStrain( peak_strain );             
108    if ( !fromPeakStrain )
109    {
110       std::cout << "Can't open file [" << peak_strain << "]" << std::endl;
111       exit(0);
112    }
113
114    std::ifstream fromStrain( strain );      
115    if ( !fromStrain )
116    {
117       std::cout << "Can't open file [" << strain << "]" << std::endl;
118       exit(0);
119    }
120      
121    std::string strStudyUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
122        
123    std::cout << "Success in open file [" << peak_strain << "]" << std::endl;
124    LoadPeakStrain(fromPeakStrain, GDCM_NAME_SPACE::Util::GetName(peak_strain), patientName,strStudyUID);
125    fromPeakStrain.close();  
126
127    std::cout << "Success in open file [" << strain << "]" << std::endl;
128    LoadStrain(fromStrain, GDCM_NAME_SPACE::Util::GetName(strain), patientName, createMultiFrame, strStudyUID);
129    fromStrain.close();      
130    return 1;            
131 }
132
133 // =====================================================================================================================
134
135 void LoadPeakStrain(std::ifstream &from, std::string textFileName, const char * patientname,std::string studyUID)
136 {
137 // in sax_base_slice0_peak_strain.txt :
138
139 /*
140 Number of material points (NP) = 181
141 Origin of (readout, phase enc, slice sel) coordinates in 3D =  87.3243 3.19392
142 88.2381
143 Readout direction in 3D =  -0.162314 -0.0771294 -0.983720
144 Phase Enc. direction in 3D =  -0.540606 -0.827052 0.154046
145 Slice select direction in 3D =  0.825469 -0.556809 -0.0925458
146 The following are the (readout, phase enc, slice sel) coordinates (mm) of the grid points for which strains are calculated,
147 followed by their peak Ecc strain, an array of NP elements,
148 followed by their peak Err strain, an array of NP elements,
149 followed by their peak E11 strain, an array of NP elements,
150 followed by their Peak E22 strain, an array of NP elements,
151       42.0000      10.0000     0.000000
152       ...
153     -0.154905   -0.0840482    -0.157350    -0.221403    -0.168118    -0.131331
154     -0.153781    -0.148481    -0.166602    -0.232858    -0.222650    -0.213712
155     ...
156 */  
157
158    if (!from)
159       return;
160
161    std::string str1;
162    int NP;
163
164    //Number of material points (NP) = 181   
165     from >> str1;
166     from >> str1;
167     from >> str1;
168     from >> str1;
169     from >> str1;
170     from >> str1;
171     from >> NP;
172
173     std::cout << "NP : " << NP << std::endl; 
174
175    //Origin of (readout, phase enc, slice sel) coordinates in 3D =  87.3243 3.19392 88.2381
176      from >> str1;
177      from >> str1;
178      from >> str1;
179      from >> str1;
180      from >> str1;
181      from >> str1;
182      from >> str1;
183      from >> str1;
184      from >> str1;
185      from >> str1;
186      from >> str1;
187
188      float readout,  phase_enc, slice_sel;
189      from >> readout;
190      from >> phase_enc;
191      from >> slice_sel;
192      std::cout << " readout " << readout << " phase_enc " << phase_enc << " slice_sel " << slice_sel << std::endl;
193
194     // Readout direction in 3D =  -0.162314 -0.0771294 -0.983720
195
196     from >> str1;
197     from >> str1;
198     from >> str1;
199     from >> str1;
200     from >> str1;
201
202     float readoutX, readoutY, readoutZ;
203     from >> readoutX;
204     from >> readoutY;       
205     from >> readoutZ;
206     std::cout << " readoutX " << readoutX <<  " readoutY " << readoutY <<  " readoutZ " << readoutZ << std::endl;
207
208 // Phase Enc. direction in 3D =  -0.540606 -0.827052 0.154046
209
210      from >> str1;
211      from >> str1;
212      from >> str1;
213      from >> str1;
214      from >> str1;
215      from >> str1;
216
217     float phase_encX, phase_encY, phase_encZ;
218     from >> phase_encX;
219     from >> phase_encY;       
220     from >> phase_encZ;
221     std::cout << " phase_encX " << phase_encX <<  " phase_encY " << phase_encY <<  " phase_encZ " << phase_encZ << std::endl; 
222
223 // Slice select direction in 3D =  0.825469 -0.556809 -0.0925458
224      from >> str1;
225      from >> str1;
226      from >> str1;
227      from >> str1;
228      from >> str1;
229      from >> str1;
230
231     float slice_selX, slice_selY, slice_selZ;
232     from >> slice_selX;
233     from >> slice_selY;       
234     from >> slice_selZ;
235     std::cout << " slice_selX " << slice_selX <<  " slice_selY " << slice_selY <<  " slice_selZ " << slice_selZ << std::endl; 
236
237
238 // Skip 5 lines :
239 /*
240 The following are the (readout, phase enc, slice sel) coordinates (mm) of the grid points for which strains are calculated,
241 followed by their peak Ecc strain, an array of NP elements,
242 followed by their peak Err strain, an array of NP elements,
243 followed by their peak E11 strain, an array of NP elements,
244 followed by their Peak E22 strain, an array of NP elements,
245 */
246
247 std::cout << "------------start skipping 1 line---------------- " << std::endl;
248    std::getline(from, str1);
249    std::cout << "[" << str1 << "]" << std::endl;
250 std::cout << "------------start skipping 1 line---------------- " << std::endl;
251    std::getline(from, str1);
252    std::cout << "[" << str1 << "]" << std::endl;
253 std::cout << "------------start skipping 1 line---------------- " << std::endl;
254    std::getline(from, str1);
255    std::cout << "[" << str1 << "]" << std::endl;
256 std::cout << "------------start skipping 1 line---------------- " << std::endl;
257    std::getline(from, str1);
258    std::cout << "[" << str1 << "]" << std::endl;
259 std::cout << "------------start skipping 1 line---------------- " << std::endl;
260    std::getline(from, str1);
261    std::cout << "[" << str1 << "]" << std::endl;
262 std::cout << "------------start skipping 1 line---------------- " << std::endl;
263    std::getline(from, str1);
264    std::cout << "[" << str1 << "]" << std::endl;
265 std::cout << "------------stop skipping ---------------- " << std::endl;
266
267    float *X = new float[NP];
268    float *Y = new float[NP];   
269    float *Z = new float[NP];
270
271    char c;
272    int i;   
273    for (i=0; i<NP; i++) {
274
275       from >> X[i];
276       for (;;) {
277         if (!from.get(c))
278           break;
279         if (!isspace(c)) {
280           from.putback(c);
281           break;
282         }
283      }
284
285       from >> Y[i];  
286       for (;;) {
287         if (!from.get(c))
288           break;
289         if (!isspace(c)) {
290           from.putback(c);
291           break;
292         }
293      }     
294       from >> Z[i];
295
296    } // end for i<NP
297
298    std::string dcmImageName;    
299    std::string serieUID;
300
301    std::cout << "--------------- Ecc_strain ------------------" << std::endl;
302    float *ecc_strain = new float[NP];
303    for (i=0; i<NP; i++) {
304       from >> ecc_strain[i]; 
305      // if (verbose)
306      //    std::cout <<  ecc_strain[i] <<  std::endl;
307    }
308 //followed by their peak Ecc strain, an array of NP elements,
309    serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
310    dcmImageName = textFileName + "_peak_Ecc_strain.dcm";
311    MakeDicomImage(ecc_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);   
312    delete []ecc_strain;
313
314    std::cout << "--------------- Err_strain ------------------" << std::endl;
315    float *err_strain = new float[NP];
316    for (i=0; i<NP; i++) {
317       from >> err_strain[i]; 
318       //if (verbose)
319       //   std::cout <<  err_strain[i] <<  std::endl;
320    }
321 //followed by their peak Err strain, an array of NP elements,
322    serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
323    dcmImageName = textFileName + "_peak_Err_strain.dcm";
324    MakeDicomImage(err_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);
325    delete []err_strain;
326
327    std::cout << "--------------- E11_strain ------------------" << std::endl;
328    float *e11_strain = new float[NP];
329    for (i=0; i<NP; i++) {
330       from >> e11_strain[i]; 
331       //if (verbose)
332       //   std::cout <<  e11_strain[i] <<  std::endl;
333    }
334 //followed by their peak E11 strain, an array of NP elements,
335    serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
336    dcmImageName = textFileName + "_peak_E11_strain.dcm";
337    MakeDicomImage(e11_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);
338    delete []e11_strain;          
339
340
341    std::cout << "--------------- E22_strain ------------------" << std::endl;
342    float *e22_strain = new float[NP];
343    for (i=0; i<NP; i++) {
344       from >> e22_strain[i]; 
345       //if (verbose)
346       //   std::cout <<  e22_strain[i] <<  std::endl;
347    }
348 //followed by their Peak E22 strain, an array of NP elements,
349    serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
350    dcmImageName = textFileName + "_peak_E22_strain.dcm";
351    MakeDicomImage(e22_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);         
352    delete []e22_strain;
353      
354 }
355
356 // =====================================================================================================================
357
358 void LoadStrain(std::ifstream &from, std::string textFileName, const char * patientname, bool createMultiFrame, std::string studyUID)
359 {
360
361 // in sax_base_slice0_strain.txt :
362 /*
363 Number of cine frames = 18
364 Temporal resolution = 32.0000 ms
365 First frame starts at 48.0000 ms
366 Number of material points (NP) = 181
367 Origin of (readout, phase enc, slice sel) coordinates in 3D =  87.324341 3.193918 88.238113 
368 Readout direction in 3D =  -0.162314 -0.0771294 -0.983720
369 Phase Enc. direction in 3D =  -0.540606 -0.827052 0.154046
370 Slice select direction in 3D =  0.825469 -0.556809 -0.0925458
371 The following are the (readout, phase enc, slice sel) coordinates (mm) of the grid points for which strains are calculated,
372 followed by their Ecc strain, an array of dimensions(NP, number of cine frames),
373 followed by their Err strain, an array of dimensions(NP, number of cine frames),
374 followed by their E11 strain, an array of dimensions(NP, number of cine frames),
375 followed by their E22 strain, an array of dimensions(NP, number of cine frames),
376 Note that RV Err, E11 and E22 strains are not calculated due to the small thickness.
377       42.0000      10.0000     0.000000
378       44.0000      10.0000     0.000000
379       ...
380    -0.0622793   -0.0840482    -0.157350    -0.196722    -0.105844    -0.131331
381     -0.153781  -0.00940573   -0.0542236    -0.100403   -0.0369671   -0.0696840      
382 */ 
383
384    if (!from)
385       return;
386
387    std::string str1;
388    int NP;    // Number of Points
389    int NCF;   // Number of cine frames
390    float TR;  // Temporal resolution
391    float FFS; // First frame starts
392
393    // Number of cine frames = 18
394     from >> str1;
395     from >> str1;
396     from >> str1;
397     from >> str1;
398     from >> str1;
399     from >> NCF;
400
401    // Temporal resolution = 32.0000 ms
402     from >> str1;
403     from >> str1;
404     from >> str1;
405     from >> TR;
406     from >> str1;
407
408    // First frame starts at 48.0000 ms
409     from >> str1;
410     from >> str1;
411     from >> str1;
412     from >> str1;
413     from >> FFS;
414     from >> str1;        
415
416    //Number of material points (NP) = 181   
417     from >> str1;
418     from >> str1;
419     from >> str1;
420     from >> str1;
421     from >> str1;
422     from >> str1;
423     from >> NP;
424
425     std::cout << "NP : " << NP << std::endl; 
426
427    //Origin of (readout, phase enc, slice sel) coordinates in 3D = 87.324341 3.193918 88.238113 
428      from >> str1;
429      from >> str1;
430      from >> str1;
431      from >> str1;
432      from >> str1;
433      from >> str1;
434      from >> str1;
435      from >> str1;
436      from >> str1;
437      from >> str1;
438      from >> str1;
439
440      float readout,  phase_enc, slice_sel;
441      from >> readout;
442      from >> phase_enc;
443      from >> slice_sel;
444      std::cout << " readout " << readout << " phase_enc " << phase_enc << " slice_sel " << slice_sel << std::endl;
445
446     // Readout direction in 3D =  -0.162314 -0.0771294 -0.983720
447
448     from >> str1;
449     from >> str1;
450     from >> str1;
451     from >> str1;
452     from >> str1;
453
454     float readoutX, readoutY, readoutZ;
455     from >> readoutX;
456     from >> readoutY;       
457     from >> readoutZ;
458     std::cout << " readoutX " << readoutX <<  " readoutY " << readoutY <<  " readoutZ " << readoutZ << std::endl;
459
460 // Phase Enc. direction in 3D =  -0.540606 -0.827052 0.154046
461
462      from >> str1;
463      from >> str1;
464      from >> str1;
465      from >> str1;
466      from >> str1;
467      from >> str1;
468
469     float phase_encX, phase_encY, phase_encZ;
470     from >> phase_encX;
471     from >> phase_encY;       
472     from >> phase_encZ;
473     std::cout << " phase_encX " << phase_encX <<  " phase_encY " << phase_encY <<  " phase_encZ " << phase_encZ << std::endl; 
474
475 // Slice select direction in 3D =  0.825469 -0.556809 -0.0925458
476      from >> str1;
477      from >> str1;
478      from >> str1;
479      from >> str1;
480      from >> str1;
481      from >> str1;
482      
483     float slice_selX, slice_selY, slice_selZ;
484     from >> slice_selX;
485     from >> slice_selY;       
486     from >> slice_selZ;
487     std::cout << " slice_selX " << slice_selX <<  " slice_selY " << slice_selY <<  " slice_selZ " << slice_selZ << std::endl; 
488
489
490
491 // Skip 6 lines :
492 /*
493 The following are the (readout, phase enc, slice sel) coordinates (mm) of the grid points for which strains are calculated,
494 followed by their Ecc strain, an array of dimensions(NP, number of cine frames),
495 followed by their Err strain, an array of dimensions(NP, number of cine frames),
496 followed by their E11 strain, an array of dimensions(NP, number of cine frames),
497 followed by their E22 strain, an array of dimensions(NP, number of cine frames),
498 Note that RV Err, E11 and E22 strains are not calculated due to the small thickness.
499 */
500 std::cout << "------------start skipping 1 line---------------- " << std::endl;
501    std::getline(from, str1);
502    std::cout << "[" << str1 << "]" << std::endl;
503 std::cout << "------------start skipping 1 line---------------- " << std::endl;
504    std::getline(from, str1);
505    std::cout << "[" << str1 << "]" << std::endl;
506 std::cout << "------------start skipping 1 line---------------- " << std::endl;
507    std::getline(from, str1);
508    std::cout << "[" << str1 << "]" << std::endl;
509 std::cout << "------------start skipping 1 line---------------- " << std::endl;
510    std::getline(from, str1);
511    std::cout << "[" << str1 << "]" << std::endl;
512 std::cout << "------------start skipping 1 line---------------- " << std::endl;
513    std::getline(from, str1);
514    std::cout << "[" << str1 << "]" << std::endl;
515 std::cout << "------------start skipping 1 line---------------- " << std::endl;
516    std::getline(from, str1);
517    std::cout << "[" << str1 << "]" << std::endl;
518 std::cout << "------------stop skipping ---------------- " << std::endl;
519    std::getline(from, str1);
520    std::cout << "[" << str1 << "]" << std::endl;
521 std::cout << "------------stop skipping ---------------- " << std::endl;
522   
523    float *X = new float[NP];
524    float *Y = new float[NP];   
525    float *Z = new float[NP];
526       
527    char c;
528    int i;   
529    for (i=0; i<NP; i++) {
530    
531       from >> X[i];
532       for (;;) {
533         if (!from.get(c))
534           break;
535         if (!isspace(c)) {
536           from.putback(c);
537           break;
538         }
539      }  
540       from >> Y[i];  
541       for (;;) {
542         if (!from.get(c))
543           break;
544         if (!isspace(c)) {
545           from.putback(c);
546           break;
547         }
548      }        
549       from >> Z[i];              
550    }
551
552 char frame[10];
553 std::string dcmImageName;    
554 std::string serieUID;
555
556 std::cout << "=======================================================================================" << createMultiFrame << std::endl;
557 if(!createMultiFrame) {     // One image per file here (single frame)
558
559 serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
560 float *ecc_strain = new float[NP];
561 for (int nbr_of_frames=0; nbr_of_frames < NCF;  nbr_of_frames++)
562 {
563 sprintf(frame, "_%d", nbr_of_frames);
564
565    std::cout << "--------------- Ecc_strain ------------------" << std::endl;
566    for (i=0; i<NP; i++) {
567        from >> ecc_strain[i];
568        if (verbose)
569        std::cout <<  ecc_strain[i] <<  std::endl;
570    }
571 //followed by their Ecc strain, an array of NP elements,
572    dcmImageName = textFileName + frame + "_Ecc_strain.dcm";
573    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
574    MakeDicomImage(ecc_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);      
575 }// end for   nbr_of_frames
576 delete []ecc_strain;
577
578 serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
579 float *err_strain = new float[NP];
580 for (int nbr_of_frames=0; nbr_of_frames < NCF;  nbr_of_frames++)
581 {
582 sprintf(frame, "_%d", nbr_of_frames);
583    std::cout << "--------------- Err_strain ------------------" << std::endl;
584    for (i=0; i<NP; i++) {
585        from >> err_strain[i]; 
586        if (verbose)
587        std::cout <<  err_strain[i] <<  std::endl;
588    }
589 //followed by their  Err strain, an array of NP elements,
590    dcmImageName = textFileName + frame + "_Err_strain.dcm";
591    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
592    MakeDicomImage(err_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);
593 }// end for   nbr_of_frames
594 delete []err_strain;
595  
596 serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
597 float *e11_strain = new float[NP];
598 for (int nbr_of_frames=0; nbr_of_frames < NCF;  nbr_of_frames++)
599 {
600 sprintf(frame, "_%d", nbr_of_frames);   
601    std::cout << "--------------- E11_strain ------------------" << std::endl;
602    for (i=0; i<NP; i++) {
603        from >> e11_strain[i]; 
604        if (verbose)
605        std::cout <<  e11_strain[i] <<  std::endl;
606    }  
607 //followed by their E11 strain, an array of NP elements,
608    dcmImageName = textFileName + frame + "_E11_strain.dcm";
609    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
610    MakeDicomImage(e11_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);
611 }// end for   nbr_of_frames   
612 delete []e11_strain;
613
614 serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
615 float *e22_strain = new float[NP];
616 for (int nbr_of_frames=0; nbr_of_frames < NCF;  nbr_of_frames++)
617 {
618 sprintf(frame, "_%d", nbr_of_frames); 
619    std::cout << "--------------- E22_strain ------------------" << std::endl;
620    for (i=0; i<NP; i++) {
621        from >> e22_strain[i]; 
622        if (verbose)
623        std::cout <<  e22_strain[i] <<  std::endl;
624    }   
625 //followed by their E22 strain, an array of NP elements,
626    dcmImageName = textFileName + frame + "_E22_strain.dcm";
627    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
628    MakeDicomImage(e22_strain, X, Y, Z, NP, dcmImageName, patientname, 1, studyUID, serieUID);   
629 } // end for   nbr_of_frames
630 delete [] e22_strain;
631  
632 } // end of single frame
633
634
635 else                      // generate Multiframe files
636 {
637
638
639 serieUID =  GDCM_NAME_SPACE::Util::CreateUniqueUID();
640 float *ecc_strain = new float[NP*NCF];
641    std::cout << "--------------- Ecc_strain ------------------" << std::endl;
642    for (i=0; i<NP*NCF; i++) {
643        from >> ecc_strain[i];
644        if (verbose)
645        std::cout <<  ecc_strain[i] <<  std::endl;
646    }
647 //followed by their Ecc strain, an array of NP elements,
648    dcmImageName = textFileName + "_Ecc_strain.dcm";
649    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
650    MakeDicomImage(ecc_strain, X, Y, Z, NP, dcmImageName, patientname, NCF, studyUID, serieUID);      
651 delete []ecc_strain;
652
653
654
655 float *err_strain = new float[NP*NCF];
656    std::cout << "--------------- Err_strain ------------------" << std::endl;
657    for (i=0; i<NP*NCF; i++) {
658        from >> err_strain[i];
659        if (verbose)
660        std::cout <<  err_strain[i] <<  std::endl;
661    }
662 //followed by their Ecc strain, an array of NP elements,
663    dcmImageName = textFileName + "_Err_strain.dcm";
664    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
665    MakeDicomImage(err_strain, X, Y, Z, NP, dcmImageName, patientname, NCF, studyUID, serieUID);      
666 delete []err_strain;
667
668
669
670 float *e11_strain = new float[NP*NCF];
671    std::cout << "--------------- E11_strain ------------------" << std::endl;
672    for (i=0; i<NP*NCF; i++) {
673        from >> e11_strain[i];
674        if (verbose)
675        std::cout <<  e11_strain[i] <<  std::endl;
676    }
677 //followed by their Ecc strain, an array of NP elements,
678    dcmImageName = textFileName + "_E11_strain.dcm";
679    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
680    MakeDicomImage(e11_strain, X, Y, Z, NP, dcmImageName, patientname, NCF, studyUID, serieUID);      
681 delete []e11_strain;
682
683
684
685 float *e22_strain = new float[NP*NCF];
686    std::cout << "--------------- E22_strain ------------------" << std::endl;
687    for (i=0; i<NP*NCF; i++) {
688        from >> e22_strain[i];
689        if (verbose)
690        std::cout <<  e22_strain[i] <<  std::endl;
691    }
692 //followed by their Ecc strain, an array of NP elements,
693    dcmImageName = textFileName + "_E22_strain.dcm";
694    std::cout << "Try to make image :[" << dcmImageName << "]" << std::endl;
695    MakeDicomImage(e22_strain, X, Y, Z, NP, dcmImageName, patientname, NCF, studyUID, serieUID);      
696 delete []e22_strain;
697
698 }    // end of Multiframe    
699 }
700
701
702 // =====================================================================================================================
703     
704
705 void MakeDicomImage(float *tabVal, float *X, float *Y, float *Z, int NP, std::string dcmImageName, const char * patientName, int nbFrames, std::string studyUID, std::string serieUID)
706 {
707
708 std::cout << "=============================================================================="
709           << "enter MakeDicomImage [" << dcmImageName << "] [" << patientName << "]" << std::endl;
710    float minX = 99999., minY = 99999., minZ = 99999.;
711    float maxX = 0., maxY = 0., maxZ = 0.;
712    int i;
713    
714    for (i=0; i<NP; i++) {
715       // std::cout << X[i] << " " << Y[i] << " " << Z[i] <<  std::endl;
716       if(maxX < X[i])
717          maxX = X[i];
718       if(maxY < Y[i])
719          maxY = Y[i];
720       if(maxZ < Z[i])
721          maxZ = Z[i];
722  
723       if(minX > X[i])
724          minX = X[i];
725       if(minY > Y[i])
726          minY = Y[i];
727       if(minZ > Z[i])
728          minZ = Z[i];
729    }   
730    std::cout << "Min X,Y,Z " << minX << " " << minY << " " << minZ <<  std::endl;
731    std::cout << "Max X,Y,Z " << maxX << " " << maxY << " " << maxZ <<  std::endl;
732    std::cout << "Size X,Y,Z " << maxX-minX << " " << maxY-minY << " " << maxZ-minZ <<  std::endl;      
733
734    int lgrFrame = int(maxX*4.)*int(maxY*4.);
735    uint16_t *img = new uint16_t[lgrFrame*nbFrames ];
736
737    // Set whole image to 0 
738    for(int i3=0; i3<lgrFrame*nbFrames; i3++)
739       img[i3] = 0;
740        
741 for(int i4=0; i4<nbFrames; i4++)
742    for(int i2=0; i2<NP; i2++) {   
743       int ordX = int(X[i2]*4.-30);
744       int ordY = int(maxY*4.) - int(Y[i2]*4.)+30;      
745       img[ lgrFrame*i4 + ordX   +  ordY   * int(maxX*4.) ] = int(tabVal[i2 + NP*i4]*100);
746
747       // Try to round up, just to see.   
748        for(int iii=ordY-3; iii<ordY+4; iii++) 
749           for(int jjj=ordX-3; jjj<ordX+4; jjj++) 
750              img[  lgrFrame*i4 + jjj  +  iii   * int(maxX*4.) ] = int(tabVal[i2 + NP*i4]*100);            
751    }
752
753  std::cout << "===========sortie recup points" << std::endl; 
754  // GDCM_NAME_SPACE::Debug::DebugOn();
755   
756    std::ostringstream str;
757
758    GDCM_NAME_SPACE::File *file;
759    file = GDCM_NAME_SPACE::File::New();       
760       
761   // Set the image size
762    str.str(""); 
763    str << (int)(maxX*4.);
764    file->InsertEntryString(str.str(),0x0028,0x0011,"US"); // Columns
765    str.str("");
766    str << (int)(maxY*4.);
767    file->InsertEntryString(str.str(),0x0028,0x0010,"US"); // Rows
768
769   // Set the pixel type
770   //      16; //8, 16, 32
771    file->InsertEntryString("16",0x0028,0x0100,"US"); // Bits Allocated
772    str.str("");
773    str << 16; // may be 12 or 16 if componentSize =16
774    file->InsertEntryString("16",0x0028,0x0101,"US"); // Bits Stored
775    file->InsertEntryString("15",0x0028,0x0102,"US"); // High Bit
776
777   // Set the pixel representation // 0/1 , 0=unsigned
778    file->InsertEntryString("1",0x0028,0x0103, "US"); // Pixel Representation
779   // Set the samples per pixel // 1:Grey level, 3:RGB
780    file->InsertEntryString("1",0x0028,0x0002, "US"); // Samples per Pixel
781
782    if (nbFrames != 1)
783    {
784       str.str("");
785       str << nbFrames;
786       file->InsertEntryString(str.str(),0x0028,0x0008,"IS"); // Number of Frames  
787    }
788   
789    if (strlen(patientName) != 0)
790       file->InsertEntryString(patientName,0x0010,0x0010, "PN"); // Patient's Name
791
792    file->InsertEntryString(studyUID, 0x0020, 0x000d, "UI");
793    file->InsertEntryString(serieUID, 0x0020, 0x000e, "UI");
794      
795    int pos = 0;  // get the usefull part of the name
796 /*  
797    for(i=0, pos=0; pos<dcmImageName.size()-4; pos++, i++) {
798      if( dcmImageName[i]=='.' &&dcmImageName[i+1]=='t' && dcmImageName[i+2]=='x' && dcmImageName[i+3]=='t'  
799        && dcmImageName[i+3]=='_') {
800        pos+=5;
801        break;
802      }
803    }
804 */  
805    file->InsertEntryString(&(dcmImageName.c_str()[pos]),0x0008,0x103e, "LO");  // Series Description   
806 /*
807   // Set Rescale Intercept
808         str.str("");
809         str << div;  
810         file->InsertEntryString(str.str(),0x0028,0x1052,"DS");
811
812   // Set Rescale Slope
813         str.str("");
814         str << mini;  
815         file->InsertEntryString(str.str(),0x0028,0x1053,"DS");
816 */
817     
818    GDCM_NAME_SPACE::FileHelper *fileH;
819    fileH = GDCM_NAME_SPACE::FileHelper::New(file);
820    // cast is just to avoid warnings (*no* conversion)
821    //fileH->SetImageData((uint8_t *)img,int(maxX*maxY)*sizeof(uint16_t)); // troubles when maxX, mayY are *actually* float!
822    
823    fileH->SetImageData((uint8_t *)img,int(maxX*4.)*int(maxY*4.)*nbFrames*sizeof(uint16_t));
824    fileH->SetWriteModeToRaw(); 
825    fileH->SetWriteTypeToDcmExplVR();
826         
827    if( !fileH->Write(dcmImageName))
828       std::cout << "Failed for [" << dcmImageName << "]\n"
829                 << "           File is unwrittable" << std::endl;
830
831    //file->Print();
832            
833    delete img;
834    file->Delete();
835    fileH->Delete();  
836 }