src/gdcmDicomDir.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmDicomDir.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2007/03/23 15:30:15 $
   7   Version:   $Revision: 1.190 $
   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 //-----------------------------------------------------------------------------
  20 //  For full DICOMDIR description, see:
  21 //  PS 3.3-2003, pages 731-750
  22 //-----------------------------------------------------------------------------
  23 #include "gdcmDicomDir.h"
  24 #include "gdcmDicomDirObject.h"
  25 #include "gdcmDicomDirStudy.h"
  26 #include "gdcmDicomDirSerie.h"
  27 #include "gdcmDicomDirVisit.h"
  28 #include "gdcmDicomDirImage.h"
  29 #include "gdcmDicomDirPrivate.h"
  30 #include "gdcmDicomDirPatient.h"
  31 #include "gdcmDicomDirMeta.h"
  32 #include "gdcmDicomDirElement.h"
  33 #include "gdcmDirList.h"
  34 #include "gdcmUtil.h"
  35 #include "gdcmDebug.h"
  36 #include "gdcmGlobal.h"
  37 #include "gdcmFile.h"
  38 #include "gdcmSeqEntry.h"
  39 #include "gdcmSQItem.h"
  40 #include "gdcmDataEntry.h"
  41 #include "gdcmCommandManager.h"
  42
  43 #include <fstream>
  44 #include <string>
  45 #include <algorithm>
  46 #include <sys/types.h>
  47
  48 #ifdef _MSC_VER
  49 #   define getcwd _getcwd
  50 #endif
  51
  52 #if defined(_MSC_VER) || defined(__BORLANDC__)
  53 #   include <direct.h>
  54 #else
  55 #   include <unistd.h>
  56 #endif
  57
  58 #if defined(__BORLANDC__)
  59    #include <mem.h> // for memset
  60 #endif
  61
  62 // ----------------------------------------------------------------------------
  63 //         Note for future developpers
  64 // ----------------------------------------------------------------------------
  65 //
  66 //  Dicom PS 3.3 describes the relationship between Directory Records, as follow
  67 //    (see also PS 4.3, 2004, page 50 for Entity-Relationship model)
  68 //
  69 //  Directory Record Type      Directory Record Types which may be included
  70 //                                in the next lower-level directory Entity
  71 //
  72 // (Root directory Entity)     PATIENT, TOPIC, PRIVATE
  73 //
  74 // PATIENT                     STUDY, PRIVATE
  75 //
  76 // STUDY                       SERIES, VISIT, RESULTS, STUDY COMPONENT, PRIVATE
  77 //
  78 // SERIES                      IMAGE, OVERLAYS, MODALITY LUT, VOI LUT,
  79 //                             CURVE, STORED PRINT, RT DOSE, RT STRUCTURE SET
  80 //                             RT PLAN, RT TREAT RECORD, PRESENTATION, WAVEFORM,
  81 //                             SR DOCUMENT, KEY OBJECT DOC, SPECTROSCOPY,
  82 //                             RAW DATA, REGISTRATION, FIDUCIAL, PRIVATE,
  83 //                             ENCAP DOC
  84 // IMAGE
  85 // OVERLAY
  86 // MODALITY LUT
  87 // VOI LUT
  88 // CURVE
  89 // STORED PRINT
  90 // RT DOSE
  91 // RT STRUCTURE SET
  92 // RT PLAN
  93 // RT TREAT RECORD
  94 // PRESENTATION
  95 // WAVEFORM
  96 // SR DOCUMENT
  97 // KEY OBJECT DOC
  98 // SPECTROSCOPY
  99 // RAW DATA
 100 // REGISTRATION
 101 // FIDUCIAL
 102 // PRIVATE
 103 // ENCAP DOC
 104 //
 105 // ----------------------
 106 // The current gdcm version only deals with :
 107 //
 108 // (Root directory Entity)     PATIENT
 109 // PATIENT                     STUDY
 110 // STUDY                       SERIES
 111 // STUDY                       VISIT
 112 // SERIES                      IMAGE
 113 // IMAGE                       /
 114 //
 115 // DicomDir::CreateDicomDir will have to be completed
 116 // Treelike structure management will have to be upgraded
 117 // ----------------------------------------------------------------------------
 118
 119 namespace gdcm
 120 {
 121 //-----------------------------------------------------------------------------
 122 // Constructor / Destructor
 123 /**
 124  * \brief   Constructor : creates an empty DicomDir
 125  */
 126 DicomDir::DicomDir()
 127 {
 128    Initialize();  // sets all private fields to NULL
 129    ParseDir = false;
 130    NewMeta();
 131 }
 132
 133 //#ifndef GDCM_LEGACY_REMOVE
 134 /**
 135  * \brief Constructor Parses recursively the directory and creates the DicomDir
 136  *        or uses an already built DICOMDIR, depending on 'parseDir' value.
 137  * @param fileName  name
 138  *                      - of the root directory (parseDir = true)
 139  *                      - of the DICOMDIR       (parseDir = false)
 140  * @param parseDir boolean
 141  *                      - true if user passed an entry point
 142  *                        and wants to explore recursively the directories
 143  *                      - false if user passed an already built DICOMDIR file
 144  *                        and wants to use it
 145  * @deprecated use : new DicomDir() + [ SetLoadMode(lm) + ] SetDirectoryName(name)
 146  *              or : new DicomDir() + SetFileName(name)
 147  */
 148  /*
 149 DicomDir::DicomDir(std::string const &fileName, bool parseDir ):
 150    Document( )
 151 {
 152    // At this step, Document constructor is already executed,
 153    // whatever user passed (either a root directory or a DICOMDIR)
 154    // and whatever the value of parseDir was.
 155    // (nothing is cheked in Document constructor, to avoid overhead)
 156
 157    ParseDir = parseDir;
 158    SetLoadMode (LD_ALL); // concerns only dicom files
 159    SetFileName( fileName );
 160    Load( );
 161 }
 162 */
 163 //#endif
 164
 165 /**
 166  * \brief  Canonical destructor
 167  */
 168 DicomDir::~DicomDir()
 169 {
 170    ClearPatient();
 171    if ( MetaElems )
 172    {
 173       MetaElems->Delete();
 174    }
 175 }
 176
 177 //-----------------------------------------------------------------------------
 178 // Public
 179
 180 /**
 181  * \brief   Loader. use SetFileName(fn)
 182  *                  or SetLoadMode(lm) + SetDirectoryName(dn)  before !
 183  * @return false if file cannot be open or no swap info was found,
 184  *         or no tag was found.
 185  */
 186 bool DicomDir::Load( )
 187 {
 188    if (!ParseDir)
 189    {
 190       if ( ! this->Document::Load( ) )
 191          return false;
 192    }
 193    return DoTheLoadingJob( );
 194 }
 195 //#ifndef GDCM_LEGACY_REMOVE
 196 /**
 197  * \brief   Loader. (DEPRECATED : kept not to break the API)
 198  * @param   fileName file to be open for parsing
 199  * @return false if file cannot be open or no swap info was found,
 200  *         or no tag was found.
 201  * @deprecated use SetFileName(n) + Load() instead
 202  */
 203  /*
 204 bool DicomDir::Load(std::string const &fileName )
 205 {
 206    // We should clean out anything that already exists.
 207    Initialize();  // sets all private fields to NULL
 208
 209    SetFileName( fileName );
 210    if (!ParseDir)
 211    {
 212       if ( ! this->Document::Load( ) )
 213          return false;
 214    }
 215    return DoTheLoadingJob( );
 216 }
 217 */
 218 //#endif
 219
 220 /**
 221  * \brief   Does the Loading Job (internal use only)
 222  * @return false if file cannot be open or no swap info was found,
 223  *         or no tag was found.
 224  */
 225 bool DicomDir::DoTheLoadingJob( )
 226 {
 227    Progress = 0.0f;
 228    Abort = false;
 229
 230    if (!ParseDir)
 231    {
 232    // Only if user passed a DICOMDIR
 233    // ------------------------------
 234       Fp = 0;
 235       if (!Document::Load() )
 236       {
 237          return false;
 238       }
 239
 240       if ( GetFirstEntry() == 0 ) // when user passed a Directory to parse
 241       {
 242          gdcmWarningMacro( "Entry HT empty for file: "<< GetFileName());
 243          return false;
 244       }
 245       // Directory record sequence
 246       DocEntry *e = GetDocEntry(0x0004, 0x1220);
 247       if ( !e )
 248       {
 249          gdcmWarningMacro( "NO 'Directory record sequence' (0x0004,0x1220)"
 250                           << " in file " << GetFileName());
 251          return false;
 252       }
 253       else
 254          CreateDicomDir();
 255    }
 256    else
 257    {
 258    // Only if user passed a root directory
 259    // ------------------------------------
 260       if ( GetFileName() == "." )
 261       {
 262          // user passed '.' as Name
 263          // we get current directory name
 264          char buf[2048];
 265          const char *cwd = getcwd(buf, 2048);
 266          if( cwd )
 267          {
 268             SetFileName( buf ); // will be converted into a string
 269          }
 270          else
 271          {
 272             gdcmErrorMacro( "Path was too long to fit on 2048 bytes" );
 273          }
 274       }
 275       NewMeta();
 276       gdcmDebugMacro( "Parse directory and create the DicomDir : "
 277                          << GetFileName() );
 278       ParseDirectory();
 279    }
 280    return true;
 281 }
 282
 283 /**
 284  * \brief  This predicate, based on hopefully reasonable heuristics,
 285  *         decides whether or not the current document was properly parsed
 286  *         and contains the mandatory information for being considered as
 287  *         a well formed and usable DicomDir.
 288  * @return true when Document is the one of a reasonable DicomDir,
 289  *         false otherwise.
 290  */
 291 bool DicomDir::IsReadable()
 292 {
 293    if ( Filetype == Unknown )
 294    {
 295       gdcmErrorMacro( "Wrong filetype for " << GetFileName());
 296       return false;
 297    }
 298    if ( !MetaElems )
 299    {
 300       gdcmWarningMacro( "Meta Elements missing in DicomDir");
 301       return false;
 302    }
 303    if ( Patients.size() <= 0 )
 304    {
 305       gdcmWarningMacro( "NO Patient in DicomDir");
 306       return false;
 307    }
 308
 309    return true;
 310 }
 311
 312 /**
 313  * \brief   adds *the* Meta to a partially created DICOMDIR
 314  */
 315 DicomDirMeta *DicomDir::NewMeta()
 316 {
 317    if ( MetaElems )
 318       MetaElems->Delete();
 319
 320    DocEntry *entry = GetFirstEntry();
 321    if ( entry )
 322    {
 323       MetaElems = DicomDirMeta::New(true); // true = empty
 324
 325       entry = GetFirstEntry();
 326       while( entry )
 327       {
 328          if ( dynamic_cast<SeqEntry *>(entry) )
 329             break;
 330
 331          MetaElems->AddEntry(entry);
 332          RemoveEntry(entry);
 333
 334          entry = GetFirstEntry();
 335       }
 336    }
 337    else  // after root directory parsing
 338    {
 339       MetaElems = DicomDirMeta::New(false); // false = not empty
 340    }
 341    MetaElems->SetSQItemNumber(0); // To avoid further missprinting
 342    return MetaElems;
 343 }
 344
 345 /**
 346  * \brief   adds a new Patient (with the basic elements) to a partially created
 347  *          DICOMDIR
 348  */
 349 DicomDirPatient *DicomDir::NewPatient()
 350 {
 351    DicomDirPatient *dd = DicomDirPatient::New();
 352    AddPatientToEnd( dd );
 353    return dd;
 354 }
 355
 356 /**
 357  * \brief   Remove all Patients
 358  */
 359 void DicomDir::ClearPatient()
 360 {
 361    for(ListDicomDirPatient::iterator cc = Patients.begin();
 362                                      cc!= Patients.end();
 363                                    ++cc)
 364    {
 365       (*cc)->Unregister();
 366    }
 367    Patients.clear();
 368 }
 369
 370 /**
 371  * \brief   Get the first entry while visiting the DicomDirPatients
 372  * \return  The first DicomDirPatient if found, otherwhise NULL
 373  */
 374 DicomDirPatient *DicomDir::GetFirstPatient()
 375 {
 376    ItPatient = Patients.begin();
 377    if ( ItPatient != Patients.end() )
 378       return *ItPatient;
 379    return NULL;
 380 }
 381
 382 /**
 383  * \brief   Get the next entry while visiting the DicomDirPatients
 384  * \note : meaningfull only if GetFirstEntry already called
 385  * \return  The next DicomDirPatient if found, otherwhise NULL
 386  */
 387 DicomDirPatient *DicomDir::GetNextPatient()
 388 {
 389    gdcmAssertMacro (ItPatient != Patients.end());
 390
 391    ++ItPatient;
 392    if ( ItPatient != Patients.end() )
 393       return *ItPatient;
 394    return NULL;
 395 }
 396
 397 /**
 398  * \brief  fills the whole structure, starting from a root Directory
 399  */
 400 void DicomDir::ParseDirectory()
 401 {
 402    CreateDicomDirChainedList( GetFileName() );
 403    CreateDicomDir();
 404 }
 405
 406 /**
 407  * \brief    writes on disc a DICOMDIR
 408  * \ warning does NOT add the missing elements in the header :
 409  *           it's up to the user doing it !
 410  * @param  fileName file to be written to
 411  * @return false only when fail to open
 412  */
 413
 414 bool DicomDir::Write(std::string const &fileName)
 415 {
 416    int i;
 417    uint16_t sq[6] = { 0x0004, 0x1220, 0x5153, 0x0000, 0xffff, 0xffff };
 418    uint16_t sqt[4]= { 0xfffe, 0xe0dd, 0x0000, 0x0000 };
 419
 420    std::ofstream *fp = new std::ofstream(fileName.c_str(),
 421                                          std::ios::out | std::ios::binary);
 422    if ( !fp )
 423    {
 424       gdcmWarningMacro("Failed to open(write) File: " << fileName.c_str());
 425       return false;
 426    }
 427
 428    char filePreamble[128];
 429    memset(filePreamble, 0, 128);
 430    fp->write(filePreamble, 128);
 431    binary_write( *fp, "DICM");
 432
 433    DicomDirMeta *ptrMeta = GetMeta();
 434    ptrMeta->WriteContent(fp, ExplicitVR);
 435
 436    // force writing 0004|1220 [SQ ], that CANNOT exist within DicomDirMeta
 437    for(i=0;i<6;++i)
 438    {
 439       binary_write(*fp, sq[i]);
 440    }
 441
 442    for(ListDicomDirPatient::iterator cc  = Patients.begin();
 443                                      cc != Patients.end();
 444                                    ++cc )
 445    {
 446       (*cc)->WriteContent( fp, ExplicitVR );
 447    }
 448
 449    // force writing Sequence Delimitation Item
 450    for(i=0;i<4;++i)
 451    {
 452       binary_write(*fp, sqt[i]);  // fffe e0dd 0000 0000
 453    }
 454
 455    fp->close();
 456    delete fp;
 457
 458    return true;
 459 }
 460
 461 /**
 462  * \brief    Anonymize a DICOMDIR
 463  * @return true
 464  */
 465
 466 bool DicomDir::Anonymize()
 467 {
 468    DataEntry *v;
 469    // Something clever to be found to forge the Patient names
 470    std::ostringstream s;
 471    int i = 1;
 472    for(ListDicomDirPatient::iterator cc = Patients.begin();
 473                                      cc!= Patients.end();
 474                                    ++cc)
 475    {
 476       s << i;
 477       v = (*cc)->GetDataEntry(0x0010, 0x0010) ; // Patient's Name
 478       if (v)
 479       {
 480          v->SetString(s.str());
 481       }
 482
 483       v = (*cc)->GetDataEntry(0x0010, 0x0020) ; // Patient ID
 484       if (v)
 485       {
 486          v->SetString(" ");
 487       }
 488
 489       v = (*cc)->GetDataEntry(0x0010, 0x0030) ; // Patient's BirthDate
 490       if (v)
 491       {
 492          v->SetString(" ");
 493       }
 494       s << "";
 495       i++;
 496    }
 497    return true;
 498 }
 499
 500 /**
 501  * \brief Copies all the attributes from an other DocEntrySet
 502  * @param set entry to copy from
 503  * @remarks The contained DocEntries are not copied, only referenced
 504  */
 505 void DicomDir::Copy(DocEntrySet *set)
 506 {
 507    // Remove all previous childs
 508    ClearPatient();
 509
 510    Document::Copy(set);
 511
 512    DicomDir *dd = dynamic_cast<DicomDir *>(set);
 513    if( dd )
 514    {
 515       if(MetaElems)
 516          MetaElems->Unregister();
 517       MetaElems = dd->MetaElems;
 518       if(MetaElems)
 519          MetaElems->Register();
 520
 521       Patients = dd->Patients;
 522       for(ItPatient = Patients.begin();ItPatient != Patients.end();++ItPatient)
 523          (*ItPatient)->Register();
 524    }
 525 }
 526
 527 //-----------------------------------------------------------------------------
 528 // Protected
 529 /**
 530  * \brief create a Document-like chained list from a root Directory
 531  * @param path entry point of the tree-like structure
 532  */
 533 void DicomDir::CreateDicomDirChainedList(std::string const &path)
 534 {
 535    CallStartMethod();
 536    DirList dirList(path,1); // gets recursively the file list
 537    unsigned int count = 0;
 538    VectDocument list;
 539    File *f;
 540
 541    DirListType fileList = dirList.GetFilenames();
 542    unsigned int nbFile = fileList.size();
 543    for( DirListType::iterator it  = fileList.begin();
 544                               it != fileList.end();
 545                               ++it )
 546    {
 547       Progress = (float)(count+1)/(float)nbFile;
 548       CallProgressMethod();
 549       if ( Abort )
 550       {
 551          break;
 552       }
 553
 554       f = File::New( );
 555       f->SetLoadMode(LoadMode); // we allow user not to load Sequences,
 556                                 //        or Shadow groups, or ......
 557       f->SetFileName( it->c_str() );
 558       f->Load( );
 559
 560       if ( f->IsReadable() )
 561       {
 562          // Add the file to the chained list:
 563          list.push_back(f);
 564          gdcmDebugMacro( "Readable " << it->c_str() );
 565        }
 566        else
 567        {
 568           f->Delete();
 569        }
 570        count++;
 571    }
 572    // sorts Patient/Study/Serie/
 573    std::sort(list.begin(), list.end(), DicomDir::HeaderLessThan );
 574
 575    std::string tmp = dirList.GetDirName();
 576    //for each File of the chained list, add/update the Patient/Study/Serie/Image info
 577    SetElements(tmp, list);
 578    CallEndMethod();
 579
 580    for(VectDocument::iterator itDoc=list.begin();
 581        itDoc!=list.end();
 582        ++itDoc)
 583    {
 584       dynamic_cast<File *>(*itDoc)->Delete();
 585    }
 586 }
 587
 588
 589 //-----------------------------------------------------------------------------
 590 // Private
 591 /**
 592  * \brief Sets all fields to NULL
 593  */
 594 void DicomDir::Initialize()
 595 {
 596    Progress = 0.0;
 597    Abort = false;
 598
 599    MetaElems = NULL;
 600 }
 601
 602 /**
 603  * \brief create a 'gdcm::DicomDir' from a DICOMDIR Header
 604  */
 605 void DicomDir::CreateDicomDir()
 606 {
 607    // The SeqEntries of "Directory Record Sequence" are parsed.
 608    //  When a DicomDir tag ("PATIENT", "STUDY", "SERIE", "IMAGE") is found :
 609    //  1 - we save the beginning iterator
 610    //  2 - we continue to parse
 611    //  3 - we find an other tag
 612    //       + we create the object for the precedent tag
 613    //       + loop to 1 -
 614    gdcmDebugMacro("Create DicomDir");
 615
 616    // Directory record sequence
 617    DocEntry *e = GetDocEntry(0x0004, 0x1220);
 618    if ( !e )
 619    {
 620       gdcmWarningMacro( "No Directory Record Sequence (0004,1220) found");
 621       return;
 622    }
 623
 624    SeqEntry *s = dynamic_cast<SeqEntry *>(e);
 625    if ( !s )
 626    {
 627       gdcmWarningMacro( "Element (0004,1220) is not a Sequence ?!?");
 628       return;
 629    }
 630
 631    NewMeta();
 632
 633    DocEntry *d;
 634    std::string v;
 635    SQItem *si;
 636
 637    SQItem *tmpSI=s->GetFirstSQItem();
 638    while(tmpSI)
 639    {
 640       d = tmpSI->GetDocEntry(0x0004, 0x1430); // Directory Record Type
 641       if ( DataEntry *dataEntry = dynamic_cast<DataEntry *>(d) )
 642       {
 643          v = dataEntry->GetString();
 644       }
 645       else
 646       {
 647          gdcmWarningMacro( "(0004,1430) not a DataEntry ?!?");
 648          continue;
 649       }
 650
 651       // A decent DICOMDIR has much more images than series,
 652       // more series than studies, and so on.
 653       // This is the right order to perform the tests
 654
 655       if ( v == "IMAGE " )
 656       {
 657          si = DicomDirImage::New(true);
 658          if ( !AddImageToEnd( static_cast<DicomDirImage *>(si)) )
 659          {
 660             si->Delete();
 661             si = NULL;
 662             gdcmErrorMacro( "Add AddImageToEnd failed");
 663          }
 664       }
 665       else if ( v == "SERIES" )
 666       {
 667          si = DicomDirSerie::New(true);
 668          if ( !AddSerieToEnd( static_cast<DicomDirSerie *>(si)) )
 669          {
 670             si->Delete();
 671             si = NULL;
 672             gdcmErrorMacro( "Add AddSerieToEnd failed");
 673          }
 674       }
 675       else if ( v == "VISIT " )
 676       {
 677          si = DicomDirVisit::New(true);
 678          if ( !AddVisitToEnd( static_cast<DicomDirVisit *>(si)) )
 679          {
 680             si->Delete();
 681             si = NULL;
 682             gdcmErrorMacro( "Add AddVisitToEnd failed");
 683          }
 684       }
 685       else if ( v == "STUDY " )
 686       {
 687          si = DicomDirStudy::New(true);
 688          if ( !AddStudyToEnd( static_cast<DicomDirStudy *>(si)) )
 689          {
 690             si->Delete();
 691             si = NULL;
 692             gdcmErrorMacro( "Add AddStudyToEnd failed");
 693          }
 694       }
 695       else if ( v == "PATIENT " )
 696       {
 697          si = DicomDirPatient::New(true);
 698          if ( !AddPatientToEnd( static_cast<DicomDirPatient *>(si)) )
 699          {
 700             si->Delete();
 701             si = NULL;
 702             gdcmErrorMacro( "Add PatientToEnd failed");
 703          }
 704       }
 705       /// \to do : deal with PRIVATE (not so easy, since PRIVATE appears
 706       ///                           at defferent levels ?!? )
 707
 708       else if ( v == "PRIVATE " ) // for SIEMENS 'CSA Non Image'
 709       {
 710
 711          gdcmWarningMacro( " -------------------------------------------"
 712               << "a PRIVATE SQItem was found : " << v);
 713          si = DicomDirPrivate::New(true);
 714          if ( !AddPrivateToEnd( static_cast<DicomDirPrivate *>(si)) )
 715          {
 716             si->Delete();
 717             si = NULL;
 718             gdcmErrorMacro( "Add PrivateToEnd failed");
 719          }
 720       }
 721       else
 722       {
 723          // It was neither a 'PATIENT', nor a 'STUDY', nor a 'SERIE',
 724          // nor an 'IMAGE' SQItem. Skip to next item.
 725          gdcmWarningMacro( " -------------------------------------------"
 726          << "a non PATIENT/STUDY/SERIE/IMAGE SQItem was found : "
 727          << v);
 728
 729         // FIXME : deal with other item types !
 730         tmpSI=s->GetNextSQItem(); // To avoid infinite loop
 731         continue;
 732       }
 733       if ( si )
 734          si->Copy(tmpSI);
 735
 736       tmpSI=s->GetNextSQItem();
 737    }
 738    ClearEntry();
 739 }
 740
 741 /**
 742  * \brief  AddPatientToEnd
 743  * @param   dd SQ Item to enqueue to the DicomPatient chained List
 744  */
 745 bool DicomDir::AddPatientToEnd(DicomDirPatient *dd)
 746 {
 747    Patients.push_back(dd);
 748    return true;
 749 }
 750
 751 /**
 752  * \brief  AddStudyToEnd
 753  * @param   dd SQ Item to enqueue to the DicomDirStudy chained List
 754  */
 755 bool DicomDir::AddStudyToEnd(DicomDirStudy *dd)
 756 {
 757    if ( Patients.size() > 0 )
 758    {
 759       ListDicomDirPatient::iterator itp = Patients.end();
 760       itp--;
 761       (*itp)->AddStudy(dd);
 762       return true;
 763    }
 764    return false;
 765 }
 766
 767 /**
 768  * \brief  AddSerieToEnd
 769  * @param   dd SQ Item to enqueue to the DicomDirSerie chained List
 770  */
 771 bool DicomDir::AddSerieToEnd(DicomDirSerie *dd)
 772 {
 773    if ( Patients.size() > 0 )
 774    {
 775       ListDicomDirPatient::iterator itp = Patients.end();
 776       itp--;
 777
 778       DicomDirStudy *study = (*itp)->GetLastStudy();
 779       if ( study )
 780       {
 781          study->AddSerie(dd);
 782          return true;
 783       }
 784    }
 785    return false;
 786 }
 787
 788 /**
 789  * \brief  AddVisitToEnd
 790  * @param   dd SQ Item to enqueue to the DicomDirVisit chained List
 791  */
 792 bool DicomDir::AddVisitToEnd(DicomDirVisit *dd)
 793 {
 794    if ( Patients.size() > 0 )
 795    {
 796       ListDicomDirPatient::iterator itp = Patients.end();
 797       itp--;
 798
 799       DicomDirStudy *study = (*itp)->GetLastStudy();
 800       if ( study )
 801       {
 802          study->AddVisit(dd);
 803          return true;
 804       }
 805    }
 806    return false;
 807 }
 808 /**
 809  * \brief   AddImageToEnd
 810  * @param   dd SQ Item to enqueue to the DicomDirImage chained List
 811  */
 812 bool DicomDir::AddImageToEnd(DicomDirImage *dd)
 813 {
 814    if ( Patients.size() > 0 )
 815    {
 816       ListDicomDirPatient::iterator itp = Patients.end();
 817       itp--;
 818
 819       DicomDirStudy *study = (*itp)->GetLastStudy();
 820       if ( study )
 821       {
 822          DicomDirSerie *serie = study->GetLastSerie();
 823          if ( serie )
 824          {
 825             serie->AddImage(dd);
 826             return true;
 827          }
 828       }
 829    }
 830    return false;
 831 }
 832
 833 /**
 834  * \brief   AddPrivateToEnd
 835  * @param   dd SQ Item to enqueue to the DicomDirPrivate chained List
 836  *          (checked for SIEMENS 'CSA non image')
 837  */
 838 bool DicomDir::AddPrivateToEnd(DicomDirPrivate *dd)
 839 {
 840    if ( Patients.size() > 0 )
 841    {
 842       ListDicomDirPatient::iterator itp = Patients.end();
 843       itp--;
 844
 845       DicomDirStudy *study = (*itp)->GetLastStudy();
 846       if ( study )
 847       {
 848          DicomDirSerie *serie = study->GetLastSerie();
 849          if ( serie )
 850          {
 851             serie->AddPrivate(dd);
 852             return true;
 853          }
 854       }
 855    }
 856    return false;
 857 }
 858
 859 /**
 860  * \brief  for each Header of the chained list,
 861  *         add/update the Patient/Study/Serie/Image info
 862  * @param   path path of the root directory
 863  * @param   list chained list of Headers
 864  */
 865 void DicomDir::SetElements(std::string const &path, VectDocument const &list)
 866 {
 867    ClearEntry();
 868    ClearPatient();
 869
 870    std::string patPrevName         = "", patPrevID  = "";
 871    std::string studPrevInstanceUID = "", studPrevID = "";
 872    std::string serPrevInstanceUID  = "", serPrevID  = "";
 873
 874    std::string patCurName,         patCurID;
 875    std::string studCurInstanceUID, studCurID;
 876    std::string serCurInstanceUID,  serCurID;
 877
 878    bool first = true;
 879    for( VectDocument::const_iterator it = list.begin();
 880                                      it != list.end();
 881                                    ++it )
 882    {
 883       // get the current file characteristics
 884       patCurName         = (*it)->GetEntryString(0x0010,0x0010);
 885       patCurID           = (*it)->GetEntryString(0x0010,0x0011);
 886       studCurInstanceUID = (*it)->GetEntryString(0x0020,0x000d);
 887       studCurID          = (*it)->GetEntryString(0x0020,0x0010);
 888       serCurInstanceUID  = (*it)->GetEntryString(0x0020,0x000e);
 889       serCurID           = (*it)->GetEntryString(0x0020,0x0011);
 890
 891       if ( patCurName != patPrevName || patCurID != patPrevID || first )
 892       {
 893          SetElement(path, GDCM_DICOMDIR_PATIENT, *it);
 894          first = true;
 895       }
 896
 897       // if new Study, deal with 'STUDY' Elements
 898       if ( studCurInstanceUID != studPrevInstanceUID || studCurID != studPrevID
 899          || first )
 900       {
 901          SetElement(path, GDCM_DICOMDIR_STUDY, *it);
 902          first = true;
 903       }
 904
 905       // if new Serie, deal with 'SERIE' Elements
 906       if ( serCurInstanceUID != serPrevInstanceUID || serCurID != serPrevID
 907          || first )
 908       {
 909          SetElement(path, GDCM_DICOMDIR_SERIE, *it);
 910       }
 911
 912       // Always Deal with 'IMAGE' Elements
 913       SetElement(path, GDCM_DICOMDIR_IMAGE, *it);
 914
 915       patPrevName         = patCurName;
 916       patPrevID           = patCurID;
 917       studPrevInstanceUID = studCurInstanceUID;
 918       studPrevID          = studCurID;
 919       serPrevInstanceUID  = serCurInstanceUID;
 920       serPrevID           = serCurID;
 921       first = false;
 922    }
 923 }
 924
 925 /**
 926  * \brief   adds to the HTable
 927  *          the Entries (Dicom Elements) corresponding to the given type
 928  * @param   path full path file name (only used when type = GDCM_DICOMDIR_IMAGE
 929  * @param   type DicomDirObject type to create (GDCM_DICOMDIR_PATIENT,
 930  *          GDCM_DICOMDIR_STUDY, GDCM_DICOMDIR_SERIE ...)
 931  * @param   header Header of the current file
 932  */
 933 void DicomDir::SetElement(std::string const &path, DicomDirType type,
 934                           Document *header)
 935 {
 936    ListDicomDirElem elemList;
 937    ListDicomDirElem::const_iterator it;
 938    uint16_t tmpGr, tmpEl;
 939    //DictEntry *dictEntry;
 940    DataEntry *entry;
 941    std::string val;
 942    SQItem *si;
 943
 944    switch( type )
 945    {
 946       case GDCM_DICOMDIR_IMAGE:
 947          elemList = Global::GetDicomDirElements()->GetDicomDirImageElements();
 948          si = DicomDirImage::New(true);
 949          if ( !AddImageToEnd(static_cast<DicomDirImage *>(si)) )
 950          {
 951             si->Delete();
 952             gdcmErrorMacro( "Add ImageToEnd failed");
 953          }
 954          break;
 955       case GDCM_DICOMDIR_SERIE:
 956          elemList = Global::GetDicomDirElements()->GetDicomDirSerieElements();
 957          si = DicomDirSerie::New(true);
 958          if ( !AddSerieToEnd(static_cast<DicomDirSerie *>(si)) )
 959          {
 960             si->Delete();
 961             gdcmErrorMacro( "Add SerieToEnd failed");
 962          }
 963          break;
 964       case GDCM_DICOMDIR_STUDY:
 965          elemList = Global::GetDicomDirElements()->GetDicomDirStudyElements();
 966          si = DicomDirStudy::New(true);
 967          if ( !AddStudyToEnd(static_cast<DicomDirStudy *>(si)) )
 968          {
 969             si->Delete();
 970             gdcmErrorMacro( "Add StudyToEnd failed");
 971          }
 972          break;
 973       case GDCM_DICOMDIR_PATIENT:
 974          elemList = Global::GetDicomDirElements()->GetDicomDirPatientElements();
 975          si = DicomDirPatient::New(true);
 976          if ( !AddPatientToEnd(static_cast<DicomDirPatient *>(si)) )
 977          {
 978             si->Delete();
 979             gdcmErrorMacro( "Add PatientToEnd failed");
 980          }
 981          break;
 982       case GDCM_DICOMDIR_META:
 983          if ( MetaElems )
 984          {
 985             MetaElems->Delete();
 986             gdcmErrorMacro( "MetaElements already exist, they will be destroyed");
 987          }
 988          elemList = Global::GetDicomDirElements()->GetDicomDirMetaElements();
 989          MetaElems = DicomDirMeta::New(true);
 990          si = MetaElems;
 991          break;
 992       default:
 993          return;
 994    }
 995
 996    // FIXME : troubles found when it's a SeqEntry
 997
 998    // removed all the seems-to-be-useless stuff about Referenced Image Sequence
 999    // to avoid further troubles
1000    // imageElem 0008 1140 "" // Referenced Image Sequence
1001    // imageElem fffe e000 "" // 'no length' item : length to be set to 0xffffffff later
1002    // imageElem 0008 1150 "" // Referenced SOP Class UID    : to be set/forged later
1003    // imageElem 0008 1155 "" // Referenced SOP Instance UID : to be set/forged later
1004    // imageElem fffe e00d "" // Item delimitation : length to be set to ZERO later
1005
1006    std::string referencedVal;
1007    // for all the relevant elements found in their own spot of the DicomDir.dic
1008    for( it = elemList.begin(); it != elemList.end(); ++it)
1009    {
1010       tmpGr     = it->Group;
1011       tmpEl     = it->Elem;
1012       //dictEntry = GetPubDict()->GetEntry(tmpGr, tmpEl);
1013       //entry     = DataEntry::New( dictEntry );
1014
1015       entry     = DataEntry::New(tmpGr, tmpEl, GDCM_VRUNKNOWN); /// \todo : modify dicomelements file, to store VR
1016       entry->SetOffset(0); // just to avoid further missprinting
1017
1018       if ( header )
1019       {
1020          // NULL when we Build Up (ex nihilo) a DICOMDIR
1021          //   or when we add the META elems
1022          val = header->GetEntryString(tmpGr, tmpEl);
1023       }
1024       else
1025       {
1026          val = GDCM_UNFOUND;
1027       }
1028
1029       if ( val == GDCM_UNFOUND)
1030       {
1031          if ( tmpGr == 0x0004 ) // never present in File !
1032          {
1033             switch (tmpEl)
1034             {
1035             case 0x1130: // File-set ID
1036                // force to the *end* File Name
1037                val = Util::GetName( path );
1038                break;
1039
1040             case 0x1500: // Only used for image
1041                if ( header->GetFileName().substr(0, path.length()) != path )
1042                {
1043                  gdcmWarningMacro( "The base path of file name is incorrect");
1044                  val = header->GetFileName();
1045                }
1046                else
1047                {
1048                  // avoid the first '/' in File name !
1049                  if ( header->GetFileName().c_str()[path.length()]
1050                                                       == GDCM_FILESEPARATOR )
1051                     val = &(header->GetFileName().c_str()[path.length()+1]);
1052                  else
1053                     val = &(header->GetFileName().c_str()[path.length()]);
1054                }
1055                break;
1056
1057              case 0x1510:  // Referenced SOP Class UID in File
1058                referencedVal = header->GetEntryString(0x0008, 0x0016);
1059                // FIXME : probabely something to check
1060                val = referencedVal;
1061                break;
1062
1063              case 0x1511: // Referenced SOP Instance UID in File
1064                referencedVal = header->GetEntryString(0x0008, 0x0018);
1065                // FIXME : probabely something to check
1066                val = referencedVal;
1067                break;
1068
1069             case 0x1512: // Referenced Transfer Syntax UID in File
1070                referencedVal = header->GetEntryString(0x0002, 0x0010);
1071                // FIXME : probabely something to check
1072                val = referencedVal;
1073                break;
1074
1075             default :
1076                val = it->Value;
1077             }
1078          }
1079          else
1080          {
1081             // If the entry is not found in the Header, don't write its 'value' in the DICOMDIR !
1082             entry->Delete();
1083             continue;
1084           }
1085       }
1086       else
1087       {
1088          if ( header->GetEntryLength(tmpGr,tmpEl) == 0 )
1089          {
1090             val = it->Value;
1091             // Don't polute the DICOMDIR with empty fields
1092             if (val == "")
1093             {
1094                entry->Delete();
1095                continue;
1096             }
1097          }
1098       }
1099
1100 /* FIX later the pb of creating the 'Implementation Version Name'!
1101
1102       if (val == GDCM_UNFOUND)
1103          val = "";
1104
1105       if ( tmpGr == 0x0002 && tmpEl == 0x0013)
1106       {
1107          // 'Implementation Version Name'
1108          std::string val = "GDCM ";
1109          val += Util::GetVersion();
1110       }
1111 */
1112
1113       entry->SetString( val ); // troubles expected when vr=SQ ...
1114
1115       if ( type == GDCM_DICOMDIR_META ) // fusible : should never print !
1116       {
1117          gdcmDebugMacro("GDCM_DICOMDIR_META ?!? should never print that");
1118       }
1119
1120       si->AddEntry(entry);
1121       entry->Delete();
1122    }
1123 }
1124
1125 /**
1126  * \brief   Move the content of the source SQItem to the destination SQItem
1127  *          Only DocEntry's are moved
1128  * @param dst destination SQItem
1129  * @param src source SQItem
1130  */
1131 void DicomDir::MoveSQItem(DocEntrySet *dst, DocEntrySet *src)
1132 {
1133    DocEntry *entry;
1134 // todo : rewrite the whole stuff, without using RemoveEntry an AddEntry,
1135 //        to save time
1136    entry = src->GetFirstEntry();
1137    while(entry)
1138    {
1139       dst->AddEntry(entry);  // use it, *before* removing it!
1140       src->RemoveEntry(entry);
1141       // we destroyed -> the current iterator is not longer valid
1142       entry = src->GetFirstEntry();
1143    }
1144 }
1145
1146 /**
1147  * \brief   compares two files
1148  */
1149 bool DicomDir::HeaderLessThan(Document *header1, Document *header2)
1150 {
1151    return *header1 < *header2;
1152 }
1153
1154 //-----------------------------------------------------------------------------
1155 // Print
1156 /**
1157  * \brief  Canonical Printer
1158  * @param   os ostream we want to print in
1159  * @param indent Indentation string to be prepended during printing
1160  */
1161 void DicomDir::Print(std::ostream &os, std::string const & )
1162 {
1163    if ( MetaElems )
1164    {
1165       MetaElems->SetPrintLevel(PrintLevel);
1166       MetaElems->Print(os);
1167    }
1168    for(ListDicomDirPatient::iterator cc  = Patients.begin();
1169                                      cc != Patients.end();
1170                                    ++cc)
1171    {
1172      (*cc)->SetPrintLevel(PrintLevel);
1173      (*cc)->Print(os);
1174    }
1175 }
1176
1177 //-----------------------------------------------------------------------------
1178 } // end namespace gdcm