]> Creatis software - gdcm.git/blob - Example/SplitIntoDirectories.cxx
no message
[gdcm.git] / Example / SplitIntoDirectories.cxx
1 /*=========================================================================
2
3   Program:   gdcm
4   Module:    $RCSfile: SplitIntoDirectories.cxx,v $
5   Language:  C++
6   Date:      $Date: 2011/08/25 14:37:05 $
7   Version:   $Revision: 1.11 $
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 #include "gdcmDocEntry.h"
19 #include "gdcmDicomDir.h"
20 #include "gdcmDicomDirPatient.h"
21 #include "gdcmFile.h"
22 #include "gdcmFileHelper.h"
23 #include "gdcmDirList.h"
24 #include "gdcmDebug.h"
25 #include "gdcmArgMgr.h"
26 #include "gdcmUtil.h"
27 #include "gdcmSerieHelper.h"
28
29 #include <iostream>
30
31 /**
32   * \brief
33   *          - explores recursively the given directory
34   *          - keeps the requested series
35   *          - orders the gdcm-readable found Files
36   *            according to their Patient/Study/Serie/Image characteristics
37   */
38
39 typedef std::map<std::string, GDCM_NAME_SPACE::File*> SortedFiles;
40
41 int main(int argc, char *argv[])
42 {
43    START_USAGE(usage)
44    " \n SplitIntoDirectories :\n                                              ",
45    " - explores recursively the given directory,                              ",
46    " - keeps the requested series / drops the unrequested series              ",
47    " - orders the gdcm-readable found Files according to their                ",
48    "           (0x0010, 0x0010) Patient's Name                                ",
49    "           (0x0020, 0x000d) Study Instance UID                            ",
50    "           (0x0020, 0x000e) Series Instance UID                           ",
51    " - fills a tree-like structure of directories as :                        ",
52    "        - Patient                                                         ",
53    "        -- Study                                                          ",
54    "        --- Serie                                                         ",
55    "                                                                          ",
56    " usage:                                                                   ",
57    " -----                                                                    ",
58    " SplitIntoDirectories                                                     ",
59    "                  dirin=rootDirectoryName                                 ",
60    "                  dirout=outputDirectoryName                              ",
61    "                  {  [keep= list of seriesNumber to process]              ",
62    "                   | [drop= list of seriesNumber to ignore] }             ",
63    "                  [listonly]  [skel] [seriedescr]                         ",
64    "                  [noshadowseq][noshadow][noseq] [verbose] [debug]        ",
65    "                                                                          ",
66    " dirout : will be created if doesn't exist                                ",
67    " keep : if user wants to process a limited number of series               ",
68    "            he gives the list of 'SeriesNumber' (tag 0020|0011)           ",
69    " drop : if user wants to ignore a limited number of series                ",
70    "            he gives the list of 'SeriesNumber' (tag 0020|0011)           ",
71    "        SeriesNumber are short enough to be human readable                ",
72    "        e.g : 1030,1035,1043                                              ",
73    " seriedescr : SerieDescription+SerieNumber use for directory name         ",
74    "              (instead of SeriesInstanceUID)                              ",
75    " skel     : name skeleton eg : patName_1.nema -> skel=patName_            ",
76    " noshadowseq: user doesn't want to load Private Sequences                 ",
77    " noshadow : user doesn't want to load Private groups (odd number)         ",
78    " noseq    : user doesn't want to load Sequences                           ",
79    " verbose  : user wants to run the program in 'verbose mode'               ",
80    " debug    : *developer*  wants to run the program in 'debug mode'         ",
81    FINISH_USAGE
82
83
84    // VERY IMPORTANT :
85    // Respect this order while creating 'UserFileIdentifier'
86    // (mind the order of the 'AddSeriesDetail' !)
87    
88    enum Index
89    {
90       IND_PatientName,
91       IND_StudyInstanceUID,
92       IND_SerieInstanceUID,
93       IND_SerieDescription,
94       IND_SerieNumber,
95       IND_FileName
96    };
97       
98    std::cout << "... inside " << argv[0] << std::endl;
99    
100    // ----- Initialize Arguments Manager ------
101
102    GDCM_NAME_SPACE::ArgMgr *am = new GDCM_NAME_SPACE::ArgMgr(argc, argv);
103   
104    if (argc == 1 || am->ArgMgrDefined("usage")) 
105    {
106       am->ArgMgrUsage(usage); // Display 'usage'
107       delete am;
108       return 0;
109    }
110
111    const char *dirNamein;
112    dirNamein  = am->ArgMgrGetString("dirin",".");
113
114    const char *dirNameout;   
115    dirNameout  = am->ArgMgrGetString("dirout",".");
116    
117    int loadMode = GDCM_NAME_SPACE::LD_ALL;
118    if ( am->ArgMgrDefined("noshadowseq") )
119       loadMode |= GDCM_NAME_SPACE::LD_NOSHADOWSEQ;
120    else
121    {
122    if ( am->ArgMgrDefined("noshadow") )
123          loadMode |= GDCM_NAME_SPACE::LD_NOSHADOW;
124       if ( am->ArgMgrDefined("noseq") )
125          loadMode |= GDCM_NAME_SPACE::LD_NOSEQ;
126    }
127
128    if (am->ArgMgrDefined("debug"))
129       GDCM_NAME_SPACE::Debug::DebugOn();
130
131    bool verbose    = ( 0 != am->ArgMgrDefined("verbose") );
132    bool listonly   = ( 0 != am->ArgMgrDefined("listonly") );
133    bool seriedescr = ( 0 != am->ArgMgrDefined("seriedescr") );
134
135    int nbSeriesToKeep;
136    int *seriesToKeep = am->ArgMgrGetListOfInt("keep", &nbSeriesToKeep);
137    int nbSeriesToDrop;
138    int *seriesToDrop = am->ArgMgrGetListOfInt("drop", &nbSeriesToDrop);
139
140    if ( nbSeriesToKeep!=0 && nbSeriesToDrop!=0)
141    {
142       std::cout << "KEEP and DROP are mutually exclusive !" << std::endl;
143       delete am;
144       return 0;
145    }
146
147    bool hasSkel = ( 0 != am->ArgMgrDefined("hasSkel") );
148    const char *skel;
149    if (hasSkel)
150       skel = am->ArgMgrGetString("skel");
151
152
153    const char *input   = am->ArgMgrGetString("input","DCM");
154    
155    // if unused Param we give up
156    if ( am->ArgMgrPrintUnusedLabels() )
157    {
158       am->ArgMgrUsage(usage);
159       delete am;
160       return 0;
161    }
162    delete am;  // we don't need Argument Manager any longer
163
164    // ----- Begin Processing -----
165    
166      
167    // --> Check supposed-to-be-directory names
168    
169    if ( ! GDCM_NAME_SPACE::DirList::IsDirectory(dirNamein) )
170    {
171       std::cout << "KO : [" << dirNamein << "] is not a Directory."
172                 << std::endl;
173       return 0;
174
175    }
176    else
177    {
178       std::cout << "OK : [" << dirNamein << "] is a Directory." << std::endl;
179    }
180
181    std::string systemCommand;
182
183    std::cout << "Check for output directory :[" << dirNameout << "]."
184              <<std::endl;
185    if ( ! GDCM_NAME_SPACE::DirList::IsDirectory(dirNameout) )    // dirout not found
186    {
187       std::string strDirNameout(dirNameout);          // to please gcc 4
188       systemCommand = "mkdir \"" +strDirNameout + "\"";        // create it!
189       if (verbose)
190          std::cout << systemCommand << std::endl;
191       system (systemCommand.c_str());
192       if ( ! GDCM_NAME_SPACE::DirList::IsDirectory(dirNameout) ) // be sure it worked
193       {
194          std::cout << "KO : not a dir : [" << dirNameout << "] (creation failure ?)" 
195                     << std::endl;
196          return 0;
197       }
198       else
199       {
200         std::cout << "Directory [" << dirNameout << "] created." << std::endl;
201       }
202    }
203    else
204    {
205        std::cout << "Output Directory [" << dirNameout 
206                  << "] already exists; Used as is."
207                  << std::endl;
208    }
209    // --> End of checking supposed-to-be-directory names
210        
211    std::string strDirNamein(dirNamein);
212    // true ; get recursively the list of files
213    GDCM_NAME_SPACE::DirList dirList(strDirNamein, true); 
214    
215    if (listonly)
216    {
217       std::cout << "------------List of found files ------------" << std::endl;
218       dirList.Print();
219       std::cout << std::endl;
220    }
221
222
223 // ======================================= The job starts here =========================
224    
225    GDCM_NAME_SPACE::DirListType fileNames;
226    fileNames = dirList.GetFilenames();
227
228    GDCM_NAME_SPACE::SerieHelper *s;     // Needed to use SerieHelper::AddSeriesDetail()
229    s = GDCM_NAME_SPACE::SerieHelper::New();
230
231    std::string token = "%%%"; // Hope it's enough!
232   
233    GDCM_NAME_SPACE::File *f;
234    std::vector<std::string> tokens;
235    std::vector<std::string> tokensForFileName;
236    
237    if (verbose)
238       std::cout << "------------------Print Break levels-----------------" << std::endl;
239
240    std::string userFileIdentifier;
241    SortedFiles sf;
242
243
244    // VERY IMPORTANT :
245    // While coding the various AddSeriesDetail,
246    // respect the order you choosed in 'enum Index' !
247  
248 /*
249    enum Index
250    {
251       IND_PatientName,
252       IND_StudyInstanceUID,
253       IND_SerieInstanceUID,
254       IND_SerieDescription,
255       IND_SerieNumber,
256       IND_FileName
257    }; 
258 */     
259    s->AddSeriesDetail(0x0010, 0x0010, false); // Patient's Name (false : no convert)
260    
261    // You may prefer 0020 0010  Study ID
262    // use :
263    // s->AddSeriesDetail(0x0020, 0x0010, true); 
264    // Avoid using 0008 0020 Study Date, 
265    // since you may have more than one study, for a given Patient, at a given Date!
266    // or the field may be empty!   
267    s->AddSeriesDetail(0x0020, 0x000d, false); // Study Instance UID (false : no convert)
268
269    // You may prefer 0020 0011 Series Number
270    // use :
271    // s->AddSeriesDetail(0x0020, 0x0011, true);    
272    s->AddSeriesDetail(0x0020, 0x000e, false); // Series Instance UID (false : no convert)
273
274    s->AddSeriesDetail(0x0008, 0x103e, false); // Serie Description
275    s->AddSeriesDetail(0x0020, 0x0011, false); // Serie Number (more than 1 serie may have the same Ser.Nbr don't 'convert!)
276
277    // Feel free to add more fields, if they can help a suitable (for you)
278    // image sorting
279
280    // Loop on all the gdcm-readable files
281    for (GDCM_NAME_SPACE::DirListType::iterator it = fileNames.begin();
282                                     it != fileNames.end();
283                                   ++it)
284    {
285       f = GDCM_NAME_SPACE::File::New();
286       f->SetLoadMode(loadMode);
287       f->SetFileName( *it );
288       if (verbose)
289          std::cout << "Try[" << *it << "]\n";
290       f->Load();
291       if (!f->Document::IsReadable())
292       {
293          if (verbose)
294             std::cout << "File : [" << *it << "] not gdcm-readable -> skipped !" << std::endl;
295          continue;
296       }
297       if (verbose)
298          std::cout << "Loaded!\n";
299       std::string strSeriesNumber;
300       int seriesNumber;
301       int j;
302
303       // keep only requested Series
304       bool keep = false;
305       if (nbSeriesToKeep != 0)
306       {
307          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
308          seriesNumber = atoi( strSeriesNumber.c_str() );
309          for (j=0; j<nbSeriesToKeep; j++)
310          {
311             if(seriesNumber == seriesToKeep[j])
312             {
313                keep = true;
314                break;
315             }
316          }
317          if ( !keep)
318          {
319             f->Delete();
320             continue;
321          }
322       }
323       // drop all unrequested Series
324       bool drop = false;
325       if (nbSeriesToDrop != 0)
326       {
327          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
328          seriesNumber = atoi( strSeriesNumber.c_str() );
329          for (j=0;j<nbSeriesToDrop; j++)
330          {
331             if(seriesNumber == seriesToDrop[j])
332             {
333                drop = true;
334                break;
335             }
336         }
337         if (drop)
338         {
339            f->Delete();
340            continue;
341         }
342       }
343
344       userFileIdentifier=s->CreateUserDefinedFileIdentifier(f);
345       if (verbose)
346          std::cout << "userFileIdentifier [" << userFileIdentifier << "]" << std::endl; 
347       tokens.clear();
348       GDCM_NAME_SPACE::Util::Tokenize (userFileIdentifier, tokens, token);
349
350       char newName[1024];
351
352       ///this is a trick to build up a lexicographical compliant name :
353       ///     eg : fich001.ima vs fich100.ima as opposed to fich1.ima vs fich100.ima
354       std::string name = GDCM_NAME_SPACE::Util::GetName( *it );
355
356      // if (verbose)
357      //    std::cout << "name :[" << name << "]\n";
358
359       if (hasSkel)
360       {
361          int imageNum; // Within FileName
362          GDCM_NAME_SPACE::Util::Tokenize (name, tokensForFileName, skel);
363          imageNum = atoi ( tokensForFileName[0].c_str() );
364          // probabely we could write something much more complicated using C++ !
365          sprintf (newName, "%s%06d.dcm", skel, imageNum);
366          tokens[IND_FileName] = newName;
367          tokensForFileName.clear();
368        }
369        else
370        {
371          tokens[IND_FileName] = name;
372        }
373
374          // Patient's Name
375          // Study Instance UID
376          // Series Instance UID
377          // SerieDescription
378          // Serie Number
379          // file Name
380
381       userFileIdentifier = tokens[IND_PatientName]      + token +
382                            tokens[IND_StudyInstanceUID] + token + 
383                            tokens[IND_SerieInstanceUID] + token +
384
385                            tokens[IND_SerieDescription] + token +
386                            tokens[IND_SerieNumber]      + token +
387                            tokens[IND_FileName];
388       if (verbose) 
389          std::cout << "[" << userFileIdentifier  << "] : " << *it << std::endl;
390
391       // storing in a map ensures automatic sorting !
392       sf[userFileIdentifier] = f;
393    }
394    
395    if (verbose)
396       std::cout << " ==== " << std::endl;
397       
398    std::string fullFilename, lastFilename;
399    std::string previousPatientName, currentPatientName;
400    std::string previousStudyInstanceUID, currentStudyInstanceUID;   
401    std::string previousSerieInstanceUID, currentSerieInstanceUID;
402    
403    std::string currentSerieDescription, currentSerieNumber;   
404       
405    std::string writeDir, currentWriteDir;
406    std::string currentPatientWriteDir;
407    std::string currentStudyWriteDir;
408    std::string currentSerieWriteDir; 
409
410    std::string fullWriteFilename;
411            
412    writeDir = GDCM_NAME_SPACE::Util::NormalizePath(dirNameout);     
413    SortedFiles::iterator it2;
414  
415    previousPatientName            = "";
416    previousStudyInstanceUID       = "";    
417    previousSerieInstanceUID       = "";   
418        
419    GDCM_NAME_SPACE::File *currentFile;
420    std::string replaceChar("_"); 
421    for (it2 = sf.begin() ; it2 != sf.end(); ++it2)
422    {  
423       currentFile = it2->second;
424        
425       fullFilename =  currentFile->GetFileName();
426       lastFilename =  GDCM_NAME_SPACE::Util::GetName( fullFilename );
427       if (verbose) 
428       std::cout <<" ------------------------------------------------------------------------------" 
429                 << std::endl << " Deal with [" << it2->first << "] : [" <<fullFilename << "]" 
430                 << std::endl;
431      
432       tokens.clear();
433       GDCM_NAME_SPACE::Util::Tokenize (it2->first, tokens, token);
434       
435       currentPatientName            = tokens[IND_PatientName];
436       currentStudyInstanceUID       = tokens[IND_StudyInstanceUID];     
437       currentSerieInstanceUID       = tokens[IND_SerieInstanceUID];
438       currentSerieDescription       = tokens[IND_SerieDescription];
439       currentSerieNumber            = tokens[IND_SerieNumber];
440
441       if (previousPatientName != currentPatientName)
442       {  
443          previousPatientName = currentPatientName;
444          if (verbose)   
445             std::cout << "==== new Patient  [" << currentPatientName  << "]" << std::endl;
446
447          previousPatientName            = currentPatientName;
448          previousStudyInstanceUID       = ""; 
449          previousSerieInstanceUID       = "";
450
451          currentPatientWriteDir = writeDir + currentPatientName;
452
453          systemCommand   = "mkdir \"" + currentPatientWriteDir + "\"";
454          if (verbose || listonly)
455             std::cout << "[" << systemCommand << "]" << std::endl;
456          if (!listonly)
457             system ( systemCommand.c_str() );
458       }
459
460       if (previousStudyInstanceUID != currentStudyInstanceUID)
461       {
462          previousStudyInstanceUID       = currentStudyInstanceUID;
463          if (verbose)
464             std::cout << "==== === new Study [" << currentStudyInstanceUID << "]"
465                       << std::endl;
466
467          currentStudyWriteDir  = currentPatientWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
468                              + currentStudyInstanceUID;
469          systemCommand   = "mkdir \"" + currentStudyWriteDir + "\"";
470  
471          if (verbose)
472             std::cout << "Directory [" << currentStudyWriteDir << "] created" << std::endl;
473  
474          if (listonly)
475             std::cout << "[" << systemCommand << "]" << std::endl;         
476          else            
477             system (systemCommand.c_str());
478       }  
479
480       if (previousSerieInstanceUID != currentSerieInstanceUID)
481       {        
482          previousSerieInstanceUID       = currentSerieInstanceUID;
483          if (verbose)   
484             std::cout << "=== ==== === new Serie [" << currentSerieInstanceUID << "]"
485                       << std::endl;
486                             
487          if (seriedescr) // more human readable!
488             currentSerieWriteDir  = currentStudyWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
489                                   + currentSerieDescription + "_" + currentSerieNumber
490                                   /*+ "_" + currentSerieInstanceUID */
491                                   ;
492
493          else
494             currentSerieWriteDir  = currentStudyWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
495                                   + currentSerieInstanceUID;         
496    
497          systemCommand   = "mkdir \"" + currentSerieWriteDir + "\"";
498          
499          if (listonly)
500             std::cout << "[" << systemCommand << "]" << std::endl;         
501          else             
502             system (systemCommand.c_str());
503
504          if (verbose)
505             std::cout << "Directory [" << currentSerieWriteDir << "] created" << std::endl;
506       }            
507    
508       if ( GDCM_NAME_SPACE::Debug::GetDebugFlag())
509          std::cout << "--- --- --- --- --- " << it2->first << "  " 
510                    << (it2->second)->GetFileName() << " " 
511                    << GDCM_NAME_SPACE::Util::GetName( fullFilename ) << std::endl;
512  
513       // If you want to create file names of your own, here is the place!
514       // Just replace 'lastFilename' by anything that's better for you.
515       GDCM_NAME_SPACE:: Util::ReplaceSpecChar(lastFilename, replaceChar);
516                    
517       fullWriteFilename = currentSerieWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR 
518                                          + lastFilename; 
519
520       systemCommand   = "cp \"" + fullFilename + "\"  " + fullWriteFilename;
521       
522       if (listonly)
523          std::cout << "[" << systemCommand << "]" << std::endl;         
524       else             
525          system (systemCommand.c_str());
526
527    }
528    return 0;
529  }