]> Creatis software - gdcm.git/blob - Example/SplitIntoDirectories.cxx
comments
[gdcm.git] / Example / SplitIntoDirectories.cxx
1 /*=========================================================================
2
3   Program:   gdcm
4   Module:    $RCSfile: SplitIntoDirectories.cxx,v $
5   Language:  C++
6   Date:      $Date: 2009/05/28 15:44:34 $
7   Version:   $Revision: 1.5 $
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
270    // You may prefer 0020 0011 Series Number
271    // use :
272    // s->AddSeriesDetail(0x0020, 0x0011, true);    
273    s->AddSeriesDetail(0x0020, 0x000e, false); // Series Instance UID (false : no convert)
274
275    s->AddSeriesDetail(0x0008, 0x103e, false); // Serie Description
276    s->AddSeriesDetail(0x0020, 0x0011, false); // Serie Number (more than 1 serie may have the same Ser.Nbr don't 'convert!)
277
278    
279    // Feel free to add more fields, if they can help a suitable (for you)
280    // image sorting
281
282    // Loop on all the gdcm-readable files
283    for (GDCM_NAME_SPACE::DirListType::iterator it = fileNames.begin();
284                                     it != fileNames.end();
285                                   ++it)
286    {
287       f = GDCM_NAME_SPACE::File::New();
288       f->SetLoadMode(loadMode);
289       f->SetFileName( *it );
290       if (verbose)
291          std::cout << "Try[" << *it << "]\n";
292       f->Load();
293       if (!f->Document::IsReadable())
294       {
295          if (verbose)
296             std::cout << "File : [" << *it << "] not gdcm-readable -> skipped !" << std::endl;
297          continue;
298       }
299       if (verbose)
300          std::cout << "Loaded!\n";
301       std::string strSeriesNumber;
302       int seriesNumber;
303       int j;
304
305       // keep only requested Series
306       bool keep = false;
307       if (nbSeriesToKeep != 0)
308       {
309          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
310          seriesNumber = atoi( strSeriesNumber.c_str() );
311          for (j=0; j<nbSeriesToKeep; j++)
312          {
313             if(seriesNumber == seriesToKeep[j])
314             {
315                keep = true;
316                break;
317             }
318          }
319          if ( !keep)
320          {
321             f->Delete();
322             continue;
323          }
324       }
325       // drop all unrequested Series
326       bool drop = false;
327       if (nbSeriesToDrop != 0)
328       {
329          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
330          seriesNumber = atoi( strSeriesNumber.c_str() );
331          for (j=0;j<nbSeriesToDrop; j++)
332          {
333             if(seriesNumber == seriesToDrop[j])
334             {
335                drop = true;
336                break;
337             }
338         }
339         if (drop)
340         {
341            f->Delete();
342            continue;
343         }
344       }
345
346       userFileIdentifier=s->CreateUserDefinedFileIdentifier(f);
347       if (verbose)
348          std::cout << "userFileIdentifier [" << userFileIdentifier << "]" << std::endl; 
349       tokens.clear();
350       GDCM_NAME_SPACE::Util::Tokenize (userFileIdentifier, tokens, token);
351
352       char newName[1024];
353
354       ///this is a trick to build up a lexicographical compliant name :
355       ///     eg : fich001.ima vs fich100.ima as opposed to fich1.ima vs fich100.ima
356       std::string name = GDCM_NAME_SPACE::Util::GetName( *it );
357
358       std::cout << "name :[" << name << "]\n";
359
360       if (hasSkel)
361       {
362          int imageNum; // Within FileName
363          GDCM_NAME_SPACE::Util::Tokenize (name, tokensForFileName, skel);
364          imageNum = atoi ( tokensForFileName[0].c_str() );
365          // probabely we could write something much more complicated using C++ !
366          sprintf (newName, "%s%06d.dcm", skel, imageNum);
367          tokens[IND_FileName] = newName;
368          tokensForFileName.clear();
369        }
370        else
371        {
372          tokens[IND_FileName] = name;
373        }
374
375          // Patient's Name
376          // Study Instance UID
377          // Series Instance UID
378          // SerieDescription
379          // Serie Number
380          // file Name
381
382       userFileIdentifier = tokens[IND_PatientName]      + token +
383                            tokens[IND_StudyInstanceUID] + token + 
384                            tokens[IND_SerieInstanceUID] + token +
385
386                            tokens[IND_SerieDescription] + token +
387                            tokens[IND_SerieNumber]      + token +
388                            tokens[IND_FileName];
389
390       if (verbose) 
391          std::cout << "[" << userFileIdentifier  << "] : " << *it << std::endl;
392
393       // storing in a map ensures automatic sorting !
394       sf[userFileIdentifier] = f;
395    }
396    
397    if (verbose)
398       std::cout << " ==== " << std::endl;
399       
400    std::string fullFilename, lastFilename;
401    std::string previousPatientName, currentPatientName;
402    std::string previousStudyInstanceUID, currentStudyInstanceUID;   
403    std::string previousSerieInstanceUID, currentSerieInstanceUID;
404    
405    std::string currentSerieDescription, currentSerieNumber;   
406       
407    std::string writeDir, currentWriteDir;
408    std::string currentPatientWriteDir;
409    std::string currentStudyWriteDir;
410    std::string currentSerieWriteDir; 
411
412    std::string fullWriteFilename;
413            
414    writeDir = GDCM_NAME_SPACE::Util::NormalizePath(dirNameout);     
415    SortedFiles::iterator it2;
416  
417    previousPatientName            = "";
418    previousStudyInstanceUID       = "";    
419    previousSerieInstanceUID       = "";   
420        
421    GDCM_NAME_SPACE::File *currentFile;
422      
423    for (it2 = sf.begin() ; it2 != sf.end(); ++it2)
424    {  
425       currentFile = it2->second;
426        
427       fullFilename =  currentFile->GetFileName();
428       lastFilename =  GDCM_NAME_SPACE::Util::GetName( fullFilename );
429       if (verbose) 
430       std::cout <<" ------------------------------------------------------------------------------" 
431                 << std::endl << " Deal with [" << it2->first << "] : [" <<fullFilename << "]" 
432                 << std::endl;
433      
434       tokens.clear();
435       GDCM_NAME_SPACE::Util::Tokenize (it2->first, tokens, token);
436       
437       currentPatientName            = tokens[IND_PatientName];
438       currentStudyInstanceUID       = tokens[IND_StudyInstanceUID];      
439       currentSerieInstanceUID       = tokens[IND_SerieInstanceUID];
440       currentSerieDescription       = tokens[IND_SerieDescription];
441       currentSerieNumber            = tokens[IND_SerieNumber];
442              
443       if (previousPatientName != currentPatientName)
444       {  
445          previousPatientName = currentPatientName;
446          if (verbose)   
447             std::cout << "==== new Patient  [" << currentPatientName  << "]" << std::endl;
448     
449          previousPatientName            = currentPatientName;
450          previousStudyInstanceUID       = ""; 
451          previousSerieInstanceUID       = "";
452
453          currentPatientWriteDir = writeDir + currentPatientName;
454
455          systemCommand   = "mkdir " + currentPatientWriteDir;
456          if (verbose || listonly)
457             std::cout << "[" << systemCommand << "]" << std::endl;
458          if (!listonly)
459             system ( systemCommand.c_str() );
460       }
461
462       if (previousStudyInstanceUID != currentStudyInstanceUID)
463       {
464          previousStudyInstanceUID       = currentStudyInstanceUID;
465          if (verbose)
466             std::cout << "==== === new Study [" << currentStudyInstanceUID << "]"
467                       << std::endl;
468
469          currentStudyWriteDir  = currentPatientWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
470                              + currentStudyInstanceUID;
471          systemCommand   = "mkdir " + currentStudyWriteDir;
472          
473          if (listonly)
474            std::cout << "[" << systemCommand << "]" << std::endl;         
475          else            
476             system (systemCommand.c_str());
477
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          else
492             currentSerieWriteDir  = currentStudyWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
493                                   + currentSerieInstanceUID;         
494                       
495          systemCommand   = "mkdir " + currentSerieWriteDir;
496          
497          if (listonly)
498             std::cout << "[" << systemCommand << "]" << std::endl;         
499          else             
500             system (systemCommand.c_str());
501       }            
502    
503       if ( GDCM_NAME_SPACE::Debug::GetDebugFlag())
504          std::cout << "--- --- --- --- --- " << it2->first << "  " 
505                    << (it2->second)->GetFileName() << " " 
506                    << GDCM_NAME_SPACE::Util::GetName( fullFilename ) << std::endl;
507  
508       // If you want to create file names of your own, here is the place!
509       // Just replace 'lastFilename' by anything that's better for you.               
510       fullWriteFilename = currentSerieWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR 
511                                          + lastFilename; 
512
513       systemCommand   = "cp " + fullFilename + " " + fullWriteFilename;
514       
515       if (listonly)
516          std::cout << "[" << systemCommand << "]" << std::endl;         
517       else             
518          system (systemCommand.c_str());
519
520    }
521    return 0;
522  }
523