src/gdcmDicomDir.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmDicomDir.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/01/06 20:03:26 $
   7   Version:   $Revision: 1.92 $
   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 "gdcmDicomDir.h"
  20 #include "gdcmDicomDirStudy.h"
  21 #include "gdcmDicomDirSerie.h"
  22 #include "gdcmDicomDirImage.h"
  23 #include "gdcmDicomDirPatient.h"
  24 #include "gdcmDicomDirMeta.h"
  25 #include "gdcmDicomDirElement.h"
  26 #include "gdcmDirList.h"
  27 #include "gdcmUtil.h"
  28 #include "gdcmDebug.h"
  29 #include "gdcmGlobal.h"
  30 #include "gdcmHeader.h"
  31 #include "gdcmSeqEntry.h"
  32 #include "gdcmSQItem.h"
  33 #include "gdcmValEntry.h"
  34
  35 #include <fstream>
  36 #include <string>
  37 #include <algorithm>
  38 #include <sys/types.h>
  39
  40 #ifdef _MSC_VER
  41 #define getcwd _getcwd
  42 #endif
  43
  44 #if defined( _MSC_VER) || defined(__BORLANDC__)
  45    #include <direct.h>
  46 #else
  47    #include <unistd.h>
  48 #endif
  49
  50 namespace gdcm
  51 {
  52
  53 //-----------------------------------------------------------------------------
  54 //  For full DICOMDIR description, see:
  55 //  PS 3.3-2003, pages 731-750
  56 //-----------------------------------------------------------------------------
  57 // Constructor / Destructor
  58
  59 /**
  60  * \ingroup DicomDir
  61  * \brief   Constructor : creates an empty DicomDir
  62  */
  63 DicomDir::DicomDir()
  64    :Document( )
  65 {
  66    Initialize();  // sets all private fields to NULL
  67    MetaElems = NewMeta();
  68 }
  69
  70 /**
  71  * \brief Constructor Parses recursively the directory and creates the DicomDir
  72  *        or uses an already built DICOMDIR, depending on 'parseDir' value.
  73  * @param fileName        name
  74  *                      - of the root directory (parseDir = true)
  75  *                      - of the DICOMDIR       (parseDir = false)
  76  * @param parseDir boolean
  77  *                      - true if user passed an entry point
  78  *                        and wants to explore recursively the directories
  79  *                      - false if user passed an already built DICOMDIR file
  80  *                        and wants to use it
  81  */
  82 DicomDir::DicomDir(std::string const &fileName, bool parseDir ):
  83    Document( fileName )
  84 {
  85    // Whatever user passed (a root directory or a DICOMDIR)
  86    // and whatever the value of parseDir was,
  87    // Document is already executed
  88    Initialize();  // sets all private fields to NULL
  89
  90    // if user passed a root directory, sure we didn't get anything
  91    if ( TagHT.begin() == TagHT.end() ) // when user passed a Directory to parse
  92    {
  93       dbg.Verbose(0, "DicomDir::DicomDir : entry HT empty");
  94
  95       if ( fileName.size() == 1 && fileName[0] == '.' )
  96       {
  97          // user passed '.' as Name
  98          // we get current directory name
  99          char dummy[1000];
 100          getcwd(dummy, (size_t)1000);
 101          SetFileName( dummy ); // will be converted into a string
 102       }
 103
 104       if ( parseDir ) // user asked for a recursive parsing of a root directory
 105       {
 106          MetaElems = NewMeta();
 107
 108          dbg.Verbose(0, "DicomDir::DicomDir : Parse directory"
 109                         " and create the DicomDir");
 110          ParseDirectory();
 111       }
 112       else
 113       {
 114          /// \todo if parseDir == false, it should be tagged as an error
 115          // NON ! il suffit d'appeler ParseDirectory()
 116          // apres le constructeur
 117       }
 118    }
 119    else // Only if user passed a DICOMDIR
 120    {
 121       // Directory record sequence
 122       DocEntry *e = GetDocEntryByNumber(0x0004, 0x1220);
 123       if ( !e )
 124       {
 125          dbg.Verbose(0, "DicomDir::DicomDir : NO Directory record"
 126                         " sequence (0x0004,0x1220)");
 127          /// \todo FIXME : what do we do when the parsed file IS NOT a
 128          ///       DICOMDIR file ?
 129       }
 130       else
 131          CreateDicomDir();
 132    }
 133 }
 134
 135 /**
 136  * \brief  Canonical destructor
 137  */
 138 DicomDir::~DicomDir()
 139 {
 140    SetStartMethod(NULL);
 141    SetProgressMethod(NULL);
 142    SetEndMethod(NULL);
 143
 144    for(ListDicomDirPatient::iterator cc = Patients.begin();
 145                                      cc!= Patients.end();
 146                                    ++cc)
 147    {
 148       delete *cc;
 149    }
 150    if ( MetaElems )
 151    {
 152       delete MetaElems;
 153    }
 154 }
 155
 156 //-----------------------------------------------------------------------------
 157 // Print
 158 /**
 159  * \brief  Canonical Printer
 160  */
 161 void DicomDir::Print(std::ostream &os)
 162 {
 163    if( MetaElems )
 164    {
 165       MetaElems->SetPrintLevel(PrintLevel);
 166       MetaElems->Print(os);
 167    }
 168    for(ListDicomDirPatient::iterator cc  = Patients.begin();
 169                                      cc != Patients.end();
 170                                    ++cc)
 171    {
 172      (*cc)->SetPrintLevel(PrintLevel);
 173      (*cc)->Print(os);
 174    }
 175 }
 176
 177 //-----------------------------------------------------------------------------
 178 // Public
 179 /**
 180  * \brief  This predicate, based on hopefully reasonable heuristics,
 181  *         decides whether or not the current header was properly parsed
 182  *         and contains the mandatory information for being considered as
 183  *         a well formed and usable DicomDir.
 184  * @return true when Document is the one of a reasonable DicomDir,
 185  *         false otherwise.
 186  */
 187 bool DicomDir::IsReadable()
 188 {
 189    if( !Document::IsReadable() )
 190    {
 191       return false;
 192    }
 193    if( !MetaElems )
 194    {
 195       return false;
 196    }
 197    if( Patients.size() <= 0 )
 198    {
 199       return false;
 200    }
 201
 202    return true;
 203 }
 204
 205 /**
 206  * \brief Sets all fields to NULL
 207  */
 208
 209 void DicomDir::Initialize()
 210 {
 211    StartMethod             = NULL;
 212    ProgressMethod          = NULL;
 213    EndMethod               = NULL;
 214    StartMethodArgDelete    = NULL;
 215    ProgressMethodArgDelete = NULL;
 216    EndMethodArgDelete      = NULL;
 217    StartArg                = NULL;
 218    ProgressArg             = NULL;
 219    EndArg                  = NULL;
 220
 221    Progress = 0.0;
 222    Abort = false;
 223
 224    MetaElems = NULL;
 225 }
 226
 227
 228 /**
 229  * \ingroup DicomDir
 230  * \brief  fills the whole structure, starting from a root Directory
 231  */
 232 void DicomDir::ParseDirectory()
 233 {
 234    CreateDicomDirChainedList( GetFileName() );
 235    CreateDicomDir();
 236 }
 237
 238 /**
 239  * \ingroup DicomDir
 240  * \brief   Set the start method to call when the parsing of the
 241  *          directory starts.
 242  * @param   method Method to call
 243  * @param   arg    Argument to pass to the method
 244  * @param   argDelete    Argument
 245  * \warning In python : the arg parameter isn't considered
 246  */
 247 void DicomDir::SetStartMethod( DicomDir::Method *method, void *arg,
 248                                DicomDir::Method *argDelete )
 249 {
 250    if( StartArg && StartMethodArgDelete )
 251    {
 252       StartMethodArgDelete( StartArg );
 253    }
 254
 255    StartMethod          = method;
 256    StartArg             = arg;
 257    StartMethodArgDelete = argDelete;
 258 }
 259
 260 /**
 261  * \ingroup DicomDir
 262  * \brief   Set the method to delete the argument
 263  *          The argument is destroyed when the method is changed or when the
 264  *          class is destroyed
 265  * @param   method Method to call to delete the argument
 266  */
 267 void DicomDir::SetStartMethodArgDelete( DicomDir::Method *method )
 268 {
 269    StartMethodArgDelete = method;
 270 }
 271
 272 /**
 273  * \ingroup DicomDir
 274  * \brief   Set the progress method to call when the parsing of the
 275  *          directory progress
 276  * @param   method Method to call
 277  * @param   arg    Argument to pass to the method
 278  * @param   argDelete    Argument
 279  * \warning In python : the arg parameter isn't considered
 280  */
 281 void DicomDir::SetProgressMethod( DicomDir::Method *method, void *arg,
 282                                   DicomDir::Method *argDelete )
 283 {
 284    if( ProgressArg && ProgressMethodArgDelete )
 285    {
 286       ProgressMethodArgDelete( ProgressArg );
 287    }
 288
 289    ProgressMethod          = method;
 290    ProgressArg             = arg;
 291    ProgressMethodArgDelete = argDelete;
 292 }
 293
 294 /**
 295  * \ingroup DicomDir
 296  * \brief   Set the method to delete the argument
 297  *          The argument is destroyed when the method is changed or when the
 298  *          class is destroyed
 299  * @param   method Method to call to delete the argument
 300  */
 301 void DicomDir::SetProgressMethodArgDelete( DicomDir::Method *method )
 302 {
 303    ProgressMethodArgDelete = method;
 304 }
 305
 306 /**
 307  * \ingroup DicomDir
 308  * \brief   Set the end method to call when the parsing of the directory ends
 309  * @param   method Method to call
 310  * @param   arg    Argument to pass to the method
 311  * @param   argDelete    Argument
 312  * \warning In python : the arg parameter isn't considered
 313  */
 314 void DicomDir::SetEndMethod( DicomDir::Method *method, void *arg,
 315                              DicomDir::Method *argDelete )
 316 {
 317    if( EndArg && EndMethodArgDelete )
 318    {
 319       EndMethodArgDelete( EndArg );
 320    }
 321
 322    EndMethod          = method;
 323    EndArg             = arg;
 324    EndMethodArgDelete = argDelete;
 325 }
 326
 327 /**
 328  * \ingroup DicomDir
 329  * \brief   Set the method to delete the argument
 330  *          The argument is destroyed when the method is changed or when
 331  *          the class is destroyed
 332  * @param   method Method to call to delete the argument
 333  */
 334 void DicomDir::SetEndMethodArgDelete( DicomDir::Method *method )
 335 {
 336    EndMethodArgDelete = method;
 337 }
 338
 339 /**
 340  * \ingroup DicomDir
 341  * \brief    writes on disc a DICOMDIR
 342  * \ warning does NOT add the missing elements in the header :
 343  *           it's up to the user doing it !
 344  * \todo : to be re-written using the DICOMDIR tree-like structure
 345  *         *not* the chained list
 346  *         (does NOT exist if the DICOMDIR is user-forged !)
 347  * @param  fileName file to be written to
 348  * @return false only when fail to open
 349  */
 350
 351 bool DicomDir::WriteDicomDir(std::string const &fileName)
 352 {
 353    int i;
 354    uint16_t sq[4] = { 0x0004, 0x1220, 0xffff, 0xffff };
 355    uint16_t sqt[4]= { 0xfffe, 0xe0dd, 0xffff, 0xffff };
 356
 357    std::ofstream *fp = new std::ofstream(fileName.c_str(),
 358                                          std::ios::out | std::ios::binary);
 359    if( !fp )
 360    {
 361       dbg.Verbose(2, "Failed to open(write) File: ", fileName.c_str());
 362       return false;
 363    }
 364
 365    char filePreamble[128];
 366    memset(filePreamble, 0, 128);
 367    fp->write(filePreamble, 128); //FIXME
 368    binary_write( *fp, "DICM");
 369
 370    DicomDirMeta *ptrMeta = GetDicomDirMeta();
 371    ptrMeta->WriteContent(fp, ExplicitVR);
 372
 373    // force writing 0004|1220 [SQ ], that CANNOT exist within DicomDirMeta
 374    for(i=0;i<4;++i)
 375    {
 376       binary_write(*fp, sq[i]);
 377    }
 378
 379    for(ListDicomDirPatient::iterator cc  = Patients.begin();
 380                                      cc != Patients.end();
 381                                    ++cc )
 382    {
 383       (*cc)->WriteContent( fp, ExplicitVR );
 384    }
 385
 386    // force writing Sequence Delimitation Item
 387    for(i=0;i<4;++i)
 388    {
 389       binary_write(*fp, sqt[i]);  // fffe e0dd ffff ffff
 390    }
 391
 392    fp->close();
 393    delete fp;
 394
 395    return true;
 396 }
 397
 398 //-----------------------------------------------------------------------------
 399 // Protected
 400
 401 /**
 402  * \ingroup DicomDir
 403  * \brief create a Document-like chained list from a root Directory
 404  * @param path entry point of the tree-like structure
 405  */
 406 void DicomDir::CreateDicomDirChainedList(std::string const & path)
 407 {
 408    CallStartMethod();
 409    DirList fileList(path,1); // gets recursively the file list
 410    unsigned int count = 0;
 411    VectDocument list;
 412    Header *header;
 413
 414    for( DirList::iterator it  = fileList.begin();
 415                               it != fileList.end();
 416                               ++it )
 417    {
 418       Progress = (float)(count+1)/(float)fileList.size();
 419       CallProgressMethod();
 420       if( Abort )
 421       {
 422          break;
 423       }
 424
 425       header = new Header( it->c_str() );
 426       if( !header )
 427       {
 428          dbg.Verbose( 1,
 429                       "DicomDir::CreateDicomDirChainedList: "
 430                       "failure in new Header ",
 431                       it->c_str() );
 432          continue;
 433       }
 434
 435       if( header->IsReadable() )
 436       {
 437          // Add the file header to the chained list:
 438          list.push_back(header);
 439          dbg.Verbose( 1,
 440                       "DicomDir::CreateDicomDirChainedList: readable ",
 441                       it->c_str() );
 442        }
 443        else
 444        {
 445           delete header;
 446        }
 447        count++;
 448    }
 449    // sorts Patient/Study/Serie/
 450    std::sort(list.begin(), list.end(), DicomDir::HeaderLessThan );
 451
 452    std::string tmp = fileList.GetDirName();
 453    //for each Header of the chained list, add/update the Patient/Study/Serie/Image info
 454    SetElements(tmp, list);
 455    CallEndMethod();
 456
 457    for(VectDocument::iterator itDoc=list.begin();
 458        itDoc!=list.end();
 459        ++itDoc)
 460    {
 461       delete dynamic_cast<Header *>(*itDoc);
 462    }
 463 }
 464
 465 /**
 466  * \ingroup DicomDir
 467  * \brief   adds *the* Meta to a partially created DICOMDIR
 468  */
 469
 470 DicomDirMeta * DicomDir::NewMeta()
 471 {
 472    DicomDirMeta *m = new DicomDirMeta();
 473
 474    if ( TagHT.begin() != TagHT.end() ) // after Document Parsing
 475    {
 476       TagDocEntryHT::iterator lastOneButSequence = TagHT.end();
 477       lastOneButSequence --;
 478       // ALL the 'out of Sequence' Tags belong to Meta Elems
 479       // (we skip 0004|1220 [Directory record sequence] )
 480       for ( TagDocEntryHT::iterator cc  = TagHT.begin();
 481                                     cc != lastOneButSequence;
 482                                    ++cc)
 483       {
 484          m->AddEntry( cc->second );
 485       }
 486    }
 487    else  // after root directory parsing
 488    {
 489       ListDicomDirMetaElem const &elemList =
 490          Global::GetDicomDirElements()->GetDicomDirMetaElements();
 491       m->FillObject(elemList);
 492    }
 493    m->SetSQItemNumber(0); // To avoid further missprinting
 494    return m;
 495 }
 496
 497 /**
 498  * \brief   adds a new Patient (with the basic elements) to a partially created DICOMDIR
 499  */
 500 DicomDirPatient *DicomDir::NewPatient()
 501 {
 502    ListDicomDirPatientElem::const_iterator it;
 503    uint16_t tmpGr,tmpEl;
 504    DictEntry *dictEntry;
 505    ValEntry *entry;
 506
 507    ListDicomDirPatientElem const & elemList =
 508       Global::GetDicomDirElements()->GetDicomDirPatientElements();
 509    DicomDirPatient *p = new DicomDirPatient();
 510
 511    // for all the DicomDirPatient Elements
 512    for( it = elemList.begin(); it != elemList.end(); ++it )
 513    {
 514       tmpGr     = it->Group;
 515       tmpEl     = it->Elem;
 516       dictEntry = GetPubDict()->GetDictEntryByNumber(tmpGr, tmpEl);
 517       entry     = new ValEntry( dictEntry );
 518       entry->SetOffset(0); // just to avoid further missprinting
 519       entry->SetValue( it->Value );
 520
 521       p->AddEntry( entry );
 522    }
 523
 524    Patients.push_front( p );
 525
 526    return p;
 527 }
 528
 529 /**
 530  * \brief   adds to the HTable
 531  *          the Entries (Dicom Elements) corresponding to the given type
 532  * @param   path full path file name (only used when type = GDCM_DICOMDIR_IMAGE
 533  * @param   type DicomDirObject type to create (GDCM_DICOMDIR_PATIENT,
 534  *          GDCM_DICOMDIR_STUDY, GDCM_DICOMDIR_SERIE ...)
 535  * @param   header Header of the current file
 536  */
 537 void DicomDir::SetElement(std::string const &path, DicomDirType type,
 538                           Document *header)
 539 {
 540    ListDicomDirElem elemList; //FIXME this is going to be a by copy operation
 541    ListDicomDirElem::const_iterator it;
 542    uint16_t tmpGr, tmpEl;
 543    DictEntry *dictEntry;
 544    ValEntry *entry;
 545    std::string val;
 546    SQItem *si;
 547
 548    switch( type )
 549    {
 550       case GDCM_DICOMDIR_IMAGE:
 551          elemList = Global::GetDicomDirElements()->GetDicomDirImageElements();
 552          si = new DicomDirImage();
 553          if( !AddDicomDirImageToEnd(static_cast<DicomDirImage *>(si)) )
 554          {
 555             dbg.Verbose(0,"DicomDir::SetElement:",
 556                         "Add DicomDirImageToEnd failed");
 557          }
 558          break;
 559       case GDCM_DICOMDIR_SERIE:
 560          elemList = Global::GetDicomDirElements()->GetDicomDirSerieElements();
 561          si = new DicomDirSerie();
 562          if( !AddDicomDirSerieToEnd(static_cast<DicomDirSerie *>(si)) )
 563          {
 564             dbg.Verbose(0,"DicomDir::SetElement:",
 565                         "Add DicomDirSerieToEnd failed");
 566          }
 567          break;
 568       case GDCM_DICOMDIR_STUDY:
 569          elemList = Global::GetDicomDirElements()->GetDicomDirStudyElements();
 570          si = new DicomDirStudy();
 571          if( !AddDicomDirStudyToEnd(static_cast<DicomDirStudy *>(si)) )
 572          {
 573             dbg.Verbose(0,"DicomDir::SetElement:",
 574                         "Add DicomDirStudyToEnd failed");
 575          }
 576          break;
 577       case GDCM_DICOMDIR_PATIENT:
 578          elemList = Global::GetDicomDirElements()->GetDicomDirPatientElements();
 579          si = new DicomDirPatient();
 580          if( !AddDicomDirPatientToEnd(static_cast<DicomDirPatient *>(si)) )
 581          {
 582             dbg.Verbose(0,"DicomDir::SetElement:",
 583                         "Add DicomDirPatientToEnd failed");
 584          }
 585          break;
 586       case GDCM_DICOMDIR_META:
 587          elemList = Global::GetDicomDirElements()->GetDicomDirMetaElements();
 588          si = new DicomDirMeta();
 589          if( MetaElems )
 590          {
 591             dbg.Verbose(0,"DicomDir::SetElement:",
 592                         "MetaElements already exist, they will be destroyed");
 593             delete MetaElems;
 594          }
 595          MetaElems = static_cast<DicomDirMeta *>(si);
 596          break;
 597       default:
 598          return;
 599    }
 600    // removed all the seems-to-be-useless stuff about Referenced Image Sequence
 601    // to avoid further troubles
 602    // imageElem 0008 1140 "" // Referenced Image Sequence
 603    // imageElem fffe e000 "" // 'no length' item : length to be set to 0xffffffff later
 604    // imageElem 0008 1150 "" // Referenced SOP Class UID    : to be set/forged later
 605    // imageElem 0008 1155 "" // Referenced SOP Instance UID : to be set/forged later
 606    // imageElem fffe e00d "" // Item delimitation : length to be set to ZERO later
 607    // for all the relevant elements found in their own spot of the DicomDir.dic
 608    // FIXME : troubles found when it's a SeqEntry
 609
 610    for( it = elemList.begin(); it != elemList.end(); ++it)
 611    {
 612       tmpGr     = it->Group;
 613       tmpEl     = it->Elem;
 614       dictEntry = GetPubDict()->GetDictEntryByNumber(tmpGr, tmpEl);
 615
 616       entry     = new ValEntry( dictEntry ); // Be sure it's never a BinEntry !
 617
 618       entry->SetOffset(0); // just to avoid further missprinting
 619
 620       if( header )
 621       {
 622          // NULL when we Build Up (ex nihilo) a DICOMDIR
 623          //   or when we add the META elems
 624          val = header->GetEntryByNumber(tmpGr, tmpEl);
 625       }
 626       else
 627       {
 628          val = GDCM_UNFOUND;
 629       }
 630
 631       if( val == GDCM_UNFOUND)
 632       {
 633          if( tmpGr == 0x0004 && tmpEl == 0x1130 ) // File-set ID
 634          {
 635            // force to the *end* File Name
 636            val = Util::GetName( path );
 637          }
 638          else if( tmpGr == 0x0004 && tmpEl == 0x1500 ) // Only used for image
 639          {
 640             if( header->GetFileName().substr(0, path.length()) != path )
 641             {
 642                dbg.Verbose(0, "DicomDir::SetElement : the base path"
 643                               " of file name is incorrect");
 644                val = header->GetFileName();
 645             }
 646             else
 647             {
 648                val = &(header->GetFileName().c_str()[path.length()]);
 649             }
 650          }
 651          else
 652          {
 653             val = it->Value;
 654          }
 655       }
 656       else
 657       {
 658          if ( header->GetEntryLengthByNumber(tmpGr,tmpEl) == 0 )
 659             val = it->Value;
 660       }
 661
 662       entry->SetValue( val ); // troubles expected when vr=SQ ...
 663
 664       if ( type == GDCM_DICOMDIR_META ) // fusible : should never print !
 665       {
 666          std::cout << "GDCM_DICOMDIR_META ?!? should never print that"
 667                    << std::endl;
 668       }
 669       si->AddEntry(entry);
 670    }
 671 }
 672
 673 //-----------------------------------------------------------------------------
 674 /**
 675  * \brief   CallStartMethod
 676  */
 677 void DicomDir::CallStartMethod()
 678 {
 679    Progress = 0.0f;
 680    Abort    = false;
 681    if( StartMethod )
 682    {
 683       StartMethod( StartArg );
 684    }
 685 }
 686
 687 //-----------------------------------------------------------------------------
 688 /**
 689  * \ingroup DicomDir
 690  * \brief   CallProgressMethod
 691  */
 692 void DicomDir::CallProgressMethod()
 693 {
 694    if( ProgressMethod )
 695    {
 696       ProgressMethod( ProgressArg );
 697    }
 698 }
 699
 700 //-----------------------------------------------------------------------------
 701 /**
 702  * \ingroup DicomDir
 703  * \brief   CallEndMethod
 704  */
 705 void DicomDir::CallEndMethod()
 706 {
 707    Progress = 1.0f;
 708    if( EndMethod )
 709    {
 710       EndMethod( EndArg );
 711    }
 712 }
 713
 714 //-----------------------------------------------------------------------------
 715 // Private
 716 /**
 717  * \ingroup DicomDir
 718  * \brief create a 'DicomDir' from a DICOMDIR Header
 719  */
 720 void DicomDir::CreateDicomDir()
 721 {
 722    // The list is parsed.
 723    //  When a DicomDir tag ("PATIENT", "STUDY", "SERIE", "IMAGE") is found :
 724    //  1 - we save the beginning iterator
 725    //  2 - we continue to parse
 726    //  3 - we find an other tag
 727    //       + we create the object for the precedent tag
 728    //       + loop to 1 -
 729
 730    // Directory record sequence
 731    DocEntry *e = GetDocEntryByNumber(0x0004, 0x1220);
 732    if ( !e )
 733    {
 734       dbg.Verbose(0, "DicomDir::DicomDir : NO Directory record"
 735                      " sequence (0x0004,0x1220)");
 736       /// \todo FIXME: what to do when the parsed file IS NOT a DICOMDIR file ?
 737       return;
 738    }
 739
 740    SeqEntry *s = dynamic_cast<SeqEntry *>(e);
 741    if ( !s )
 742    {
 743       dbg.Verbose(0, "DicomDir::CreateDicomDir: no SeqEntry present");
 744       // useless : (0x0004,0x1220) IS a Sequence !
 745       return;
 746    }
 747
 748    DicomDirType type; // = DicomDir::GDCM_DICOMDIR_META;
 749    MetaElems = NewMeta();
 750
 751    ListSQItem listItems = s->GetSQItems();
 752
 753    DocEntry *d;
 754    std::string v;
 755    SQItem *si;
 756    for( ListSQItem::iterator i = listItems.begin();
 757                              i !=listItems.end(); ++i )
 758    {
 759       d = (*i)->GetDocEntryByNumber(0x0004, 0x1430); // Directory Record Type
 760       if ( ValEntry* valEntry = dynamic_cast<ValEntry *>(d) )
 761       {
 762          v = valEntry->GetValue();
 763       }
 764       else
 765       {
 766          dbg.Verbose(0, "DicomDir::CreateDicomDir: not a ValEntry.");
 767          continue;
 768       }
 769
 770       if( v == "PATIENT " )
 771       {
 772          si = new DicomDirPatient();
 773          AddDicomDirPatientToEnd( static_cast<DicomDirPatient *>(si) );
 774          type = DicomDir::GDCM_DICOMDIR_PATIENT;
 775       }
 776       else if( v == "STUDY " )
 777       {
 778          si = new DicomDirStudy();
 779          AddDicomDirStudyToEnd( static_cast<DicomDirStudy *>(si) );
 780          type = DicomDir::GDCM_DICOMDIR_STUDY;
 781       }
 782       else if( v == "SERIES" )
 783       {
 784          si = new DicomDirSerie();
 785          AddDicomDirSerieToEnd( static_cast<DicomDirSerie *>(si) );
 786          type = DicomDir::GDCM_DICOMDIR_SERIE;
 787       }
 788       else if( v == "IMAGE " )
 789       {
 790          si = new DicomDirImage();
 791          AddDicomDirImageToEnd( static_cast<DicomDirImage *>(si) );
 792          type = DicomDir::GDCM_DICOMDIR_IMAGE;
 793       }
 794       else
 795       {
 796          // It was not a 'PATIENT', nor a 'STUDY', nor a 'SERIE',
 797          // neither an 'IMAGE' SQItem. Skip to next item.
 798          continue;
 799       }
 800       MoveSQItem(si,*i);
 801    }
 802    TagHT.clear();
 803 }
 804
 805 /**
 806  * \ingroup DicomDir
 807  * \brief Well ... there is only one occurence
 808  */
 809 bool DicomDir::AddDicomDirMeta()
 810 {
 811    if( MetaElems )
 812    {
 813       delete MetaElems;
 814    }
 815    MetaElems = new DicomDirMeta();
 816    return true;
 817 }
 818
 819 /**
 820  * \ingroup DicomDir
 821  * \brief  AddDicomDirPatientToEnd
 822  * @param   dd SQ Item to enqueue to the DicomPatient chained List
 823  */
 824 bool DicomDir::AddDicomDirPatientToEnd(DicomDirPatient *dd)
 825 {
 826    Patients.push_back(dd);
 827    return true;
 828 }
 829
 830 /**
 831  * \ingroup DicomDir
 832  * \brief  AddDicomDirStudyToEnd
 833  * @param   dd SQ Item to enqueue to the DicomDirStudy chained List
 834  */
 835 bool DicomDir::AddDicomDirStudyToEnd(DicomDirStudy *dd)
 836 {
 837    if( Patients.size() > 0 )
 838    {
 839       ListDicomDirPatient::iterator itp = Patients.end();
 840       itp--;
 841       (*itp)->AddDicomDirStudy(dd);
 842       return true;
 843    }
 844    return false;
 845 }
 846
 847 /**
 848  * \ingroup DicomDir
 849  * \brief  AddDicomDirSerieToEnd
 850  * @param   dd SQ Item to enqueue to the DicomDirSerie chained List
 851  */
 852 bool DicomDir::AddDicomDirSerieToEnd(DicomDirSerie *dd)
 853 {
 854    if( Patients.size() > 0 )
 855    {
 856       ListDicomDirPatient::iterator itp = Patients.end();
 857       itp--;
 858
 859       if( (*itp)->GetDicomDirStudies().size() > 0 )
 860       {
 861          ListDicomDirStudy::const_iterator itst =
 862             (*itp)->GetDicomDirStudies().end();
 863          itst--;
 864          (*itst)->AddDicomDirSerie(dd);
 865          return true;
 866       }
 867    }
 868    return false;
 869 }
 870
 871 /**
 872  * \ingroup DicomDir
 873  * \brief   AddDicomDirImageToEnd
 874  * @param   dd SQ Item to enqueue to the DicomDirImage chained List
 875  */
 876 bool DicomDir::AddDicomDirImageToEnd(DicomDirImage *dd)
 877 {
 878    if( Patients.size() > 0 )
 879    {
 880       ListDicomDirPatient::iterator itp = Patients.end();
 881       itp--;
 882
 883       if( (*itp)->GetDicomDirStudies().size() > 0 )
 884       {
 885          ListDicomDirStudy::const_iterator itst =
 886             (*itp)->GetDicomDirStudies().end();
 887          itst--;
 888
 889          if( (*itst)->GetDicomDirSeries().size() > 0 )
 890          {
 891             ListDicomDirSerie::const_iterator its = (*itst)->GetDicomDirSeries().end();
 892             its--;
 893             (*its)->AddDicomDirImage(dd);
 894             return true;
 895          }
 896       }
 897    }
 898    return false;
 899 }
 900
 901 /**
 902  * \ingroup DicomDir
 903  * \brief  for each Header of the chained list, add/update the Patient/Study/Serie/Image info
 904  * @param   path path of the root directory
 905  * @param   list chained list of Headers
 906  */
 907 void DicomDir::SetElements(std::string const & path, VectDocument const &list)
 908 {
 909    TagHT.clear();
 910    Patients.clear();
 911
 912    std::string patPrevName         = "", patPrevID  = "";
 913    std::string studPrevInstanceUID = "", studPrevID = "";
 914    std::string serPrevInstanceUID  = "", serPrevID  = "";
 915
 916    std::string patCurName,         patCurID;
 917    std::string studCurInstanceUID, studCurID;
 918    std::string serCurInstanceUID,  serCurID;
 919
 920    bool first = true;
 921    for( VectDocument::const_iterator it = list.begin();
 922                                      it != list.end(); ++it )
 923    {
 924       // get the current file characteristics
 925       patCurName         = (*it)->GetEntryByNumber(0x0010,0x0010);
 926       patCurID           = (*it)->GetEntryByNumber(0x0010,0x0011);
 927       studCurInstanceUID = (*it)->GetEntryByNumber(0x0020,0x000d);
 928       studCurID          = (*it)->GetEntryByNumber(0x0020,0x0010);
 929       serCurInstanceUID  = (*it)->GetEntryByNumber(0x0020,0x000e);
 930       serCurID           = (*it)->GetEntryByNumber(0x0020,0x0011);
 931
 932       if( patCurName != patPrevName || patCurID != patPrevID || first )
 933       {
 934          SetElement(path, GDCM_DICOMDIR_PATIENT, *it);
 935          first = true;
 936       }
 937
 938       // if new Study Deal with 'STUDY' Elements
 939       if( studCurInstanceUID != studPrevInstanceUID || studCurID != studPrevID
 940          || first )
 941       {
 942          SetElement(path, GDCM_DICOMDIR_STUDY, *it);
 943          first = true;
 944       }
 945
 946       // if new Serie Deal with 'SERIE' Elements
 947       if( serCurInstanceUID != serPrevInstanceUID || serCurID != serPrevID
 948          || first )
 949       {
 950          SetElement(path, GDCM_DICOMDIR_SERIE, *it);
 951          first = true;
 952       }
 953
 954       // Always Deal with 'IMAGE' Elements
 955       SetElement(path, GDCM_DICOMDIR_IMAGE, *it);
 956
 957       patPrevName         = patCurName;
 958       patPrevID           = patCurID;
 959       studPrevInstanceUID = studCurInstanceUID;
 960       studPrevID          = studCurID;
 961       serPrevInstanceUID  = serCurInstanceUID;
 962       serPrevID           = serCurID;
 963       first = false;
 964    }
 965 }
 966
 967 /**
 968  * \ingroup DicomDir
 969  * \brief   Move the content of the src SQItem to the dst SQItem
 970  *          Only DocEntry's are moved
 971  *
 972  */
 973 void DicomDir::MoveSQItem(SQItem *dst,SQItem *src)
 974 {
 975    DocEntry *entry;
 976
 977    src->Initialize();
 978    entry = src->GetNextEntry();
 979    while(entry)
 980    {
 981       src->RemoveEntryNoDestroy(entry);
 982       dst->AddEntry(entry);
 983
 984       src->Initialize();
 985       entry = src->GetNextEntry();
 986    }
 987 }
 988
 989 /**
 990  * \ingroup DicomDir
 991  * \brief   compares two dgcmHeaders
 992  */
 993 bool DicomDir::HeaderLessThan(Document *header1, Document *header2)
 994 {
 995    return *header1 < *header2;
 996 }
 997 } // end namespace gdcm
 998
 999 //-----------------------------------------------------------------------------