]> Creatis software - gdcm.git/blob - Example/SplitIntoDirectories.cxx
ENH: apply dos2unix
[gdcm.git] / Example / SplitIntoDirectories.cxx
1 /*=========================================================================
2
3   Program:   gdcm
4   Module:    $RCSfile: SplitIntoDirectories.cxx,v $
5   Language:  C++
6   Date:      $Date: 2007/10/30 11:37:16 $
7   Version:   $Revision: 1.4 $
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       }
199       else
200       {
201         std::cout << "Directory [" << dirNameout << "] created." << std::endl;
202       }
203    }
204    else
205    {
206        std::cout << "Output Directory [" << dirNameout 
207                  << "] already exists; Used as is."
208                  << std::endl;
209    }
210    // --> End of checking supposed-to-be-directory names
211        
212    std::string strDirNamein(dirNamein);
213    // true ; get recursively the list of files
214    GDCM_NAME_SPACE::DirList dirList(strDirNamein, true); 
215    
216    if (listonly)
217    {
218       std::cout << "------------List of found files ------------" << std::endl;
219       dirList.Print();
220       std::cout << std::endl;
221    }
222
223
224 // ======================================= The job starts here =========================
225    
226    GDCM_NAME_SPACE::DirListType fileNames;
227    fileNames = dirList.GetFilenames();
228
229    GDCM_NAME_SPACE::SerieHelper *s;     // Needed to use SerieHelper::AddSeriesDetail()
230    s = GDCM_NAME_SPACE::SerieHelper::New();
231
232    std::string token = "%%%"; // Hope it's enough!
233   
234    GDCM_NAME_SPACE::File *f;
235    std::vector<std::string> tokens;
236    std::vector<std::string> tokensForFileName;
237    
238    if (verbose)
239       std::cout << "------------------Print Break levels-----------------" << std::endl;
240
241    std::string userFileIdentifier;
242    SortedFiles sf;
243
244
245    // VERY IMPORTANT :
246    // While coding the various AddSeriesDetail,
247    // respect the order you choosed in 'enum Index' !
248  
249 /*
250    enum Index
251    {
252       IND_PatientName,
253       IND_StudyInstanceUID,
254       IND_SerieInstanceUID,
255       IND_SerieDescription,
256       IND_SerieNumber,
257       IND_FileName
258    }; 
259 */     
260    s->AddSeriesDetail(0x0010, 0x0010, false); // Patient's Name (false : no convert)
261    
262    // You may prefer 0020 0010  Study ID
263    // use :
264    // s->AddSeriesDetail(0x0020, 0x0010, true); 
265    // Avoid using 0008 0020 Study Date, 
266    // since you may have more than one study, for a given Patient, at a given Date!
267    // or the field may be empty!   
268    s->AddSeriesDetail(0x0020, 0x000d, false); // Study Instance UID (false : no convert)
269
270
271    // You may prefer 0020 0011 Series Number
272    // use :
273    // s->AddSeriesDetail(0x0020, 0x0011, true);    
274    s->AddSeriesDetail(0x0020, 0x000e, false); // Series Instance UID (false : no convert)
275
276    s->AddSeriesDetail(0x0008, 0x103e, false); // Serie Description
277    s->AddSeriesDetail(0x0020, 0x0011, false); // Serie Number (more than 1 serie may have the same Ser.Nbr don't 'convert!)
278
279    
280    // Feel free to add more fields, if they can help a suitable (for you)
281    // image sorting
282
283    // Loop on all the gdcm-readable files
284    for (GDCM_NAME_SPACE::DirListType::iterator it = fileNames.begin();
285                                     it != fileNames.end();
286                                   ++it)
287    {
288       f = GDCM_NAME_SPACE::File::New();
289       f->SetLoadMode(loadMode);
290       f->SetFileName( *it );
291       if (verbose)
292          std::cout << "Try[" << *it << "]\n";
293       f->Load();
294       if (!f->IsReadable())
295       {
296          if (verbose)
297             std::cout << "File : [" << *it << "] not gdcm-readable -> skipped !" << std::endl;
298          continue;     
299       }
300       if (verbose)
301          std::cout << "Loaded!\n";
302       std::string strSeriesNumber;
303       int seriesNumber;
304       int j;
305
306       // keep only requested Series
307       bool keep = false;
308       if (nbSeriesToKeep != 0)
309       {
310          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
311          seriesNumber = atoi( strSeriesNumber.c_str() );
312          for (j=0; j<nbSeriesToKeep; j++)
313          {
314             if(seriesNumber == seriesToKeep[j])
315             {
316                keep = true;
317                break;
318             }
319          }
320          if ( !keep)
321          {
322             f->Delete();
323             continue;
324          }
325       }
326       // drop all unrequested Series
327       bool drop = false;
328       if (nbSeriesToDrop != 0)
329       {     
330          strSeriesNumber = f->GetEntryString(0x0020, 0x0011 );
331          seriesNumber = atoi( strSeriesNumber.c_str() );
332          for (j=0;j<nbSeriesToDrop; j++)
333          {
334             if(seriesNumber == seriesToDrop[j])
335             { 
336                drop = true;
337                break;
338             }
339         }
340         if (drop)
341         {
342            f->Delete();
343            continue;
344         }
345       }
346
347       userFileIdentifier=s->CreateUserDefinedFileIdentifier(f);
348       if (verbose)
349          std::cout << "userFileIdentifier [" << userFileIdentifier << "]" << std::endl; 
350       tokens.clear();
351       GDCM_NAME_SPACE::Util::Tokenize (userFileIdentifier, tokens, token);
352
353       char newName[1024];
354       
355       ///this is a trick to build up a lexicographical compliant name :
356       ///     eg : fich001.ima vs fich100.ima as opposed to fich1.ima vs fich100.ima
357       std::string name = GDCM_NAME_SPACE::Util::GetName( *it );
358       
359       std::cout << "name :[" << name << "]\n";
360       
361       if (hasSkel)
362       {
363          int imageNum; // Within FileName
364          GDCM_NAME_SPACE::Util::Tokenize (name, tokensForFileName, skel);
365          imageNum = atoi ( tokensForFileName[0].c_str() );
366          // probabely we could write something much more complicated using C++ !
367          sprintf (newName, "%s%06d.dcm", skel, imageNum);
368          tokens[IND_FileName] = newName;
369          tokensForFileName.clear();
370        }
371        else
372        {
373          tokens[IND_FileName] = name;
374        }
375     
376          // Patient's Name
377          // Study Instance UID 
378          // Series Instance UID
379          // SerieDescription
380          // Serie Number
381          // file Name
382            
383       userFileIdentifier = tokens[IND_PatientName]      + token +
384                            tokens[IND_StudyInstanceUID] + token + 
385                            tokens[IND_SerieInstanceUID] + token +
386
387                            tokens[IND_SerieDescription] + token +
388                            tokens[IND_SerieNumber]      + token +
389                            tokens[IND_FileName];
390          
391       if (verbose) 
392          std::cout << "[" << userFileIdentifier  << "] : " << *it << std::endl;
393                
394       // storing in a map ensures automatic sorting !      
395       sf[userFileIdentifier] = f;
396    }
397    
398    if (verbose)
399       std::cout << " ==== " << std::endl;
400       
401    std::string fullFilename, lastFilename;
402    std::string previousPatientName, currentPatientName;
403    std::string previousStudyInstanceUID, currentStudyInstanceUID;   
404    std::string previousSerieInstanceUID, currentSerieInstanceUID;
405    
406    std::string currentSerieDescription, currentSerieNumber;   
407       
408    std::string writeDir, currentWriteDir;
409    std::string currentPatientWriteDir;
410    std::string currentStudyWriteDir;
411    std::string currentSerieWriteDir; 
412
413    std::string fullWriteFilename;
414            
415    writeDir = GDCM_NAME_SPACE::Util::NormalizePath(dirNameout);     
416    SortedFiles::iterator it2;
417  
418    previousPatientName            = "";
419    previousStudyInstanceUID       = "";    
420    previousSerieInstanceUID       = "";   
421        
422    GDCM_NAME_SPACE::File *currentFile;
423      
424    for (it2 = sf.begin() ; it2 != sf.end(); ++it2)
425    {  
426       currentFile = it2->second;
427        
428       fullFilename =  currentFile->GetFileName();
429       lastFilename =  GDCM_NAME_SPACE::Util::GetName( fullFilename );
430       if (verbose) 
431       std::cout <<" ------------------------------------------------------------------------------" 
432                 << std::endl << " Deal with [" << it2->first << "] : [" <<fullFilename << "]" 
433                 << std::endl;
434      
435       tokens.clear();
436       GDCM_NAME_SPACE::Util::Tokenize (it2->first, tokens, token);
437       
438       currentPatientName            = tokens[IND_PatientName];
439       currentStudyInstanceUID       = tokens[IND_StudyInstanceUID];      
440       currentSerieInstanceUID       = tokens[IND_SerieInstanceUID];
441       currentSerieDescription       = tokens[IND_SerieDescription];
442       currentSerieNumber            = tokens[IND_SerieNumber];
443              
444       if (previousPatientName != currentPatientName)
445       {  
446          previousPatientName = currentPatientName;
447          if (verbose)   
448             std::cout << "==== new Patient  [" << currentPatientName  << "]" << std::endl;
449     
450          previousPatientName            = currentPatientName;
451          previousStudyInstanceUID       = ""; 
452          previousSerieInstanceUID       = "";
453   
454          currentPatientWriteDir = writeDir + currentPatientName;
455
456          systemCommand   = "mkdir " + currentPatientWriteDir;
457          if (verbose || listonly)
458             std::cout << "[" << systemCommand << "]" << std::endl;
459          if (!listonly)               
460             system ( systemCommand.c_str() );
461       }
462       
463       if (previousStudyInstanceUID != currentStudyInstanceUID)
464       {        
465          previousStudyInstanceUID       = currentStudyInstanceUID;
466          if (verbose)   
467             std::cout << "==== === new Study [" << currentStudyInstanceUID << "]"
468                       << std::endl;      
469
470          currentStudyWriteDir  = currentPatientWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
471                              + currentStudyInstanceUID;
472          systemCommand   = "mkdir " + currentStudyWriteDir;
473          
474          if (listonly)
475            std::cout << "[" << systemCommand << "]" << std::endl;         
476          else            
477             system (systemCommand.c_str());
478
479       }  
480       
481       if (previousSerieInstanceUID != currentSerieInstanceUID)
482       {        
483          previousSerieInstanceUID       = currentSerieInstanceUID;
484          if (verbose)   
485             std::cout << "=== ==== === new Serie [" << currentSerieInstanceUID << "]"
486                       << std::endl;
487                             
488          if (seriedescr) // more human readable!
489             currentSerieWriteDir  = currentStudyWriteDir + GDCM_NAME_SPACE::GDCM_FILESEPARATOR
490                                   + currentSerieDescription + "_" + currentSerieNumber;
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