gdcmDicomDir.cxx

Go to the documentation of this file.

/*=========================================================================
  
  Program:   gdcm
  Module:    $RCSfile: gdcmDicomDir.cxx,v $
  Language:  C++
  Date:      $Date: 2007/07/26 08:36:49 $
  Version:   $Revision: 1.194 $
  
  Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  l'Image). All rights reserved. See Doc/License.txt or
  http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
  
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.
  
=========================================================================*/

//-----------------------------------------------------------------------------
//  For full DICOMDIR description, see:
//  PS 3.3-2003, pages 731-750
//-----------------------------------------------------------------------------
#include "gdcmDicomDir.h"
#include "gdcmDicomDirObject.h"
#include "gdcmDicomDirStudy.h"
#include "gdcmDicomDirSerie.h"
#include "gdcmDicomDirVisit.h"
#include "gdcmDicomDirImage.h"
#include "gdcmDicomDirPrivate.h"
#include "gdcmDicomDirPatient.h"
#include "gdcmDicomDirMeta.h"
#include "gdcmDicomDirElement.h"
#include "gdcmDirList.h"
#include "gdcmUtil.h"
#include "gdcmDebug.h"
#include "gdcmGlobal.h"
#include "gdcmFile.h"
#include "gdcmSeqEntry.h"
#include "gdcmSQItem.h"
#include "gdcmDataEntry.h"
#include "gdcmCommandManager.h"

#include <fstream>
#include <string>
#include <algorithm>
#include <sys/types.h>

#ifdef _MSC_VER
#   define getcwd _getcwd
#endif

#if defined(_MSC_VER) || defined(__BORLANDC__)
#   include <direct.h>
#else
#   include <unistd.h>
#endif

#if defined(__BORLANDC__)
   #include <mem.h> // for memset
#endif

// ----------------------------------------------------------------------------
//         Note for future developpers
// ----------------------------------------------------------------------------
//
//  Dicom PS 3.3 describes the relationship between Directory Records, as follow
//    (see also PS 4.3, 2004, page 50 for Entity-Relationship model)
//
//  Directory Record Type      Directory Record Types which may be included
//                                in the next lower-level directory Entity
//
// (Root directory Entity)     PATIENT, TOPIC, PRIVATE
//
// PATIENT                     STUDY, PRIVATE
//
// STUDY                       SERIES, VISIT, RESULTS, STUDY COMPONENT, PRIVATE
//
// SERIES                      IMAGE, OVERLAYS, MODALITY LUT, VOI LUT,
//                             CURVE, STORED PRINT, RT DOSE, RT STRUCTURE SET
//                             RT PLAN, RT TREAT RECORD, PRESENTATION, WAVEFORM,
//                             SR DOCUMENT, KEY OBJECT DOC, SPECTROSCOPY,
//                             RAW DATA, REGISTRATION, FIDUCIAL, PRIVATE,
//                             ENCAP DOC
// IMAGE
// OVERLAY
// MODALITY LUT
// VOI LUT
// CURVE
// STORED PRINT
// RT DOSE
// RT STRUCTURE SET
// RT PLAN
// RT TREAT RECORD
// PRESENTATION
// WAVEFORM
// SR DOCUMENT
// KEY OBJECT DOC
// SPECTROSCOPY
// RAW DATA
// REGISTRATION
// FIDUCIAL
// PRIVATE
// ENCAP DOC
// 

/*

// see also : ftp://medical.nema.org/medical/dicom/final/cp343_ft.doc

RELATIONSHIP BETWEEN DIRECTORY RECORDS

Directory Record Type      Directory Record Types which may be included 
                           in the next lower-level directory Entity

(Root Directory Entity)    PATIENT, TOPIC, PRIVATE

PATIENT                    STUDY, PRIVATE

STUDY                      SERIES, VISIT, RESULTS, STUDY COMPONENT, PRIVATE

SERIES                     IMAGE, OVERLAY, MODALITY LUT, VOI LUT, CURVE, 
                           STORED PRINT, RT DOSE, RT STRUCTURE SET, RT PLAN, 
                           RT TREAT RECORD, PRESENTATION, WAVEFORM, SR DOCUMENT,
                            KEY OBJECT DOC, SPECTROSCOPY, RAW DATA, PRIVATE

IMAGE                      PRIVATE
OVERLAY                    PRIVATE
MODALITY LUT               PRIVATE
VOI LUT                    PRIVATE
CURVE                      PRIVATE
STORED PRINT               PRIVATE
RT DOSE                    PRIVATE
RT STRUCTURE SET           PRIVATE
RT PLAN                    PRIVATE
RT TREAT RECORD            PRIVATE
PRESENTATION               PRIVATE
WAVEFORM                   PRIVATE
SR DOCUMENT                PRIVATE
KEY OBJECT DOC             PRIVATE
SPECTROSCOPY               PRIVATE
RAW DATA                   PRIVATE

TOPIC                      STUDY, SERIES, IMAGE, OVERLAY, MODALITY LUT, VOI LUT,
                           CURVE, STORED PRINT, RT DOSE, RT STRUCTURE SET, 
                           RT PLAN, RT TREAT RECORD, PRESENTATION, WAVEFORM, 
                           SR DOCUMENT, KEY OBJECT DOC, SPECTROSCOPY, RAW DATA, 
                           PRIVATE

VISIT                      PRIVATE

RESULTS                    INTERPRETATION, PRIVATE

INTERPRETATION             PRIVATE
STUDY COMPONENT            PRIVATE
PRIVATE                    PRIVATE, (any of the above as privately defined)
MRDR                      (Not applicable)

Note :   Directory Record Types PRINT QUEUE, FILM SESSION, FILM BOX, and 
         IMAGE BOX  were previously defined in DICOM.  They have been retired.  
         See PS 3.3-1998.
*/

// ----------------------
// The current gdcm version only deals with :
//
// (Root directory Entity)     PATIENT
// PATIENT                     STUDY
// STUDY                       SERIES
// STUDY                       VISIT 
// SERIES                      IMAGE
// IMAGE                       /
//
// DicomDir::CreateDicomDir will have to be completed
// Treelike structure management will have to be upgraded
// ----------------------------------------------------------------------------
    
namespace GDCM_NAME_SPACE 
{
//-----------------------------------------------------------------------------
// Constructor / Destructor
DicomDir::DicomDir()
{
   Initialize();  // sets all private fields to NULL
   ParseDir = false;
   NewMeta();
}

//#ifndef GDCM_LEGACY_REMOVE
 /*
DicomDir::DicomDir(std::string const &fileName, bool parseDir ):
   Document( )
{
   // At this step, Document constructor is already executed,
   // whatever user passed (either a root directory or a DICOMDIR)
   // and whatever the value of parseDir was.
   // (nothing is checked in Document constructor, to avoid overhead)

   ParseDir = parseDir;
   SetLoadMode (LD_ALL); // concerns only dicom files
   SetFileName( fileName );
   Load( );
}
*/
//#endif

DicomDir::~DicomDir() 
{
   ClearPatient();
   if ( MetaElems )
   {
      MetaElems->Delete();
   }
}

//-----------------------------------------------------------------------------
// Public

bool DicomDir::Load( ) 
{
   if (!ParseDir)
   {
      if ( ! this->Document::Load( ) )
         return false;
   }
   return DoTheLoadingJob( );   
}
//#ifndef GDCM_LEGACY_REMOVE
 /*
bool DicomDir::Load(std::string const &fileName ) 
{
   // We should clean out anything that already exists.
   Initialize();  // sets all private fields to NULL

   SetFileName( fileName );
   if (!ParseDir)
   {
      if ( ! this->Document::Load( ) )
         return false;
   }
   return DoTheLoadingJob( );
}
*/
//#endif

bool DicomDir::DoTheLoadingJob( ) 
{
   Progress = 0.0f;
   Abort = false;

   if (!ParseDir)
   {
   // Only if user passed a DICOMDIR
   // ------------------------------
      Fp = 0;
      if (!Document::Load() )
      {
         return false;
      }

      if ( GetFirstEntry() == 0 ) // when user passed a Directory to parse
      {
         gdcmWarningMacro( "Entry HT empty for file: "<< GetFileName());
         return false;
      }
      // Directory record sequence
      DocEntry *e = GetDocEntry(0x0004, 0x1220);
      if ( !e )
      {
         gdcmWarningMacro( "NO 'Directory record sequence' (0x0004,0x1220)"
                          << " in file " << GetFileName());
         return false;
      }
      else
      {
         CreateDicomDir();
      }
   }
   else
   {
   // Only if user passed a root directory
   // ------------------------------------
      if ( GetFileName() == "." )
      {
         // user passed '.' as Name
         // we get current directory name
         char buf[2048];
         const char *cwd = getcwd(buf, 2048);
         if( cwd )
         {
            SetFileName( buf ); // will be converted into a string
         }
         else
         {
            gdcmErrorMacro( "Path was too long to fit on 2048 bytes" );
         }
      }
      NewMeta();
      gdcmDebugMacro( "Parse directory and create the DicomDir : " 
                         << GetFileName() );
      ParseDirectory();
   }
   return true;
}

bool DicomDir::IsReadable()
{
   if ( Filetype == Unknown )
   {
      gdcmErrorMacro( "Wrong filetype for " << GetFileName());
      return false;
   }
   if ( !MetaElems )
   {
      gdcmWarningMacro( "Meta Elements missing in DicomDir");
      return false;
   }
   if ( Patients.size() <= 0 )
   {
      gdcmWarningMacro( "NO Patient in DicomDir");
      return false;
   }

   return true;
}

DicomDirMeta *DicomDir::NewMeta()
{
   if ( MetaElems )
   {
      MetaElems->Delete();
   }
   DocEntry *entry = GetFirstEntry();
   if ( entry )
   { 
      MetaElems = DicomDirMeta::New(true); // true = empty

      entry = GetFirstEntry();
      while( entry )
      {
         if ( dynamic_cast<SeqEntry *>(entry) )
            break;

         MetaElems->AddEntry(entry);
         RemoveEntry(entry);

         entry = GetFirstEntry();
      }
   }
   else  // after root directory parsing
   {
      MetaElems = DicomDirMeta::New(false); // false = not empty
   }
   MetaElems->SetSQItemNumber(0); // To avoid further missprinting
   return MetaElems;  
}

DicomDirPatient *DicomDir::NewPatient()
{
   DicomDirPatient *dd = DicomDirPatient::New();
   AddPatientToEnd( dd );
   return dd;
}

void DicomDir::ClearPatient()
{
   for(ListDicomDirPatient::iterator cc = Patients.begin();
                                     cc!= Patients.end();
                                   ++cc)
   {
      (*cc)->Unregister();
   }
   Patients.clear();
}

DicomDirPatient *DicomDir::GetFirstPatient()
{
   ItPatient = Patients.begin();
   if ( ItPatient != Patients.end() )
      return *ItPatient;
   return NULL;
}

DicomDirPatient *DicomDir::GetNextPatient()
{
   gdcmAssertMacro (ItPatient != Patients.end());

   ++ItPatient;
   if ( ItPatient != Patients.end() )
      return *ItPatient;
   return NULL;
}

void DicomDir::ParseDirectory()
{
   CreateDicomDirChainedList( GetFileName() );
   CreateDicomDir();
}

bool DicomDir::Write(std::string const &fileName) 
{  
   int i;
   uint16_t sq[6] = { 0x0004, 0x1220, 0x5153, 0x0000, 0xffff, 0xffff };
   uint16_t sqt[4]= { 0xfffe, 0xe0dd, 0x0000, 0x0000 };

   std::ofstream *fp = new std::ofstream(fileName.c_str(),  
                                         std::ios::out | std::ios::binary);
   if ( !fp ) 
   {
      gdcmWarningMacro("Failed to open(write) File: " << fileName.c_str());
      return false;
   }

   char filePreamble[128];
   memset(filePreamble, 0, 128);
   fp->write(filePreamble, 128);
   binary_write( *fp, "DICM");
 
   DicomDirMeta *ptrMeta = GetMeta();
   ptrMeta->WriteContent(fp, ExplicitVR, true);
   
   // force writing 0004|1220 [SQ ], that CANNOT exist within DicomDirMeta
   for(i=0;i<6;++i)
   {
      binary_write(*fp, sq[i]);
   }
        
   for(ListDicomDirPatient::iterator cc  = Patients.begin();
                                     cc != Patients.end();
                                   ++cc )
   {
      (*cc)->WriteContent( fp, ExplicitVR, false );
   }
   
   // force writing Sequence Delimitation Item
   for(i=0;i<4;++i)
   {
      binary_write(*fp, sqt[i]);  // fffe e0dd 0000 0000 
   }

   fp->close();
   delete fp;

   return true;
}

bool DicomDir::Anonymize() 
{
   DataEntry *v;
   // Something clever to be found to forge the Patient names
   std::ostringstream s;
   int i = 1;
   for(ListDicomDirPatient::iterator cc = Patients.begin();
                                     cc!= Patients.end();
                                   ++cc)
   {
      s << i;
      v = (*cc)->GetDataEntry(0x0010, 0x0010) ; // Patient's Name
      if (v)
      {
         v->SetString(s.str());
      }

      v = (*cc)->GetDataEntry(0x0010, 0x0020) ; // Patient ID
      if (v)
      {
         v->SetString(" ");
      }

      v = (*cc)->GetDataEntry(0x0010, 0x0030) ; // Patient's BirthDate
      if (v)
      {
         v->SetString(" ");
      }
      s << "";
      i++;
   }
   return true;
}

void DicomDir::Copy(DocEntrySet *set)
{
   // Remove all previous childs
   ClearPatient();

   Document::Copy(set);

   DicomDir *dd = dynamic_cast<DicomDir *>(set);
   if( dd )
   {
      if(MetaElems)
         MetaElems->Unregister();
      MetaElems = dd->MetaElems;
      if(MetaElems)
         MetaElems->Register();

      Patients = dd->Patients;
      for(ItPatient = Patients.begin();ItPatient != Patients.end();++ItPatient)
         (*ItPatient)->Register();
   }
}

//-----------------------------------------------------------------------------
// Protected
void DicomDir::CreateDicomDirChainedList(std::string const &path)
{
   CallStartMethod();
   DirList dirList(path,1); // gets recursively the file list
   unsigned int count = 0;
   VectDocument list;
   File *f;

   DirListType fileList = dirList.GetFilenames();
   unsigned int nbFile = fileList.size();
   for( DirListType::iterator it  = fileList.begin();
                              it != fileList.end();
                              ++it )
   {
      Progress = (float)(count+1)/(float)nbFile;
      CallProgressMethod();
      if ( Abort )
      {
         break;
      }

      f = File::New( );
      f->SetLoadMode(LoadMode); // we allow user not to load Sequences, 
                                //        or Shadow groups, or ......
      f->SetFileName( it->c_str() );
      f->Load( );

      if ( f->IsReadable() )
      {
         // Add the file to the chained list:
         list.push_back(f);
         gdcmDebugMacro( "Readable " << it->c_str() );
       }
       else
       {
          f->Delete();
       }
       count++;
   }
   // sorts Patient/Study/Serie/
   std::sort(list.begin(), list.end(), DicomDir::HeaderLessThan );
   
   std::string tmp = dirList.GetDirName();      
   //for each File of the chained list, add/update the Patient/Study/Serie/Image info
   SetElements(tmp, list);
   CallEndMethod();

   for(VectDocument::iterator itDoc=list.begin();
       itDoc!=list.end();
       ++itDoc)
   {
      dynamic_cast<File *>(*itDoc)->Delete();
   }
}


//-----------------------------------------------------------------------------
// Private
void DicomDir::Initialize()
{
   Progress = 0.0;
   Abort = false;

   MetaElems = NULL;   
}

void DicomDir::CreateDicomDir()
{
   // The SeqEntries of "Directory Record Sequence" are parsed. 
   //  When a DicomDir tag ("PATIENT", "STUDY", "SERIE", "IMAGE") is found :
   //                    N.B. :  VISIT, PRIVATE not fully dealt with
   //  1 - we save the beginning iterator
   //  2 - we continue to parse
   //  3 - we find an other tag
   //       + we create the object for the precedent tag
   //       + loop to 1 -
   gdcmDebugMacro("Create DicomDir");

   // Directory record sequence
   DocEntry *e = GetDocEntry(0x0004, 0x1220);
   if ( !e )
   {
      gdcmWarningMacro( "No Directory Record Sequence (0004,1220) found");
      return;         
   }
   
   SeqEntry *s = dynamic_cast<SeqEntry *>(e);
   if ( !s )
   {
      gdcmWarningMacro( "Element (0004,1220) is not a Sequence ?!?");
      return;
   }

   NewMeta();
   
   DocEntry *d;
   std::string v;
   SQItem *si;

   SQItem *tmpSI=s->GetFirstSQItem();
   while(tmpSI)
   {
      d = tmpSI->GetDocEntry(0x0004, 0x1430); // Directory Record Type
      if ( DataEntry *dataEntry = dynamic_cast<DataEntry *>(d) )
      {
         v = dataEntry->GetString();
      }
      else
      {
         gdcmWarningMacro( "(0004,1430) not a DataEntry ?!?");
         continue;
      }

      // A decent DICOMDIR has much more images than series,
      // more series than studies, and so on.
      // This is the right order to perform the tests

      if ( v == "IMAGE " ) 
      {
         si = DicomDirImage::New(true); // true = empty
         if ( !AddImageToEnd( static_cast<DicomDirImage *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add AddImageToEnd failed");
         }
      }
      else if ( v == "SERIES" )
      {
         si = DicomDirSerie::New(true);  // true = empty
         if ( !AddSerieToEnd( static_cast<DicomDirSerie *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add AddSerieToEnd failed");
         }
      }
      else if ( v == "VISIT " )
      {
         si = DicomDirVisit::New(true);  // true = empty
         if ( !AddVisitToEnd( static_cast<DicomDirVisit *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add AddVisitToEnd failed");
         }
      }
      else if ( v == "STUDY " )
      {
         si = DicomDirStudy::New(true);  // true = empty
         if ( !AddStudyToEnd( static_cast<DicomDirStudy *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add AddStudyToEnd failed");
         }
      }
      else if ( v == "PATIENT " )
      {
         si = DicomDirPatient::New(true);  // true = empty
         if ( !AddPatientToEnd( static_cast<DicomDirPatient *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add PatientToEnd failed");
         }
      }
      
      else if ( v == "PRIVATE " ) // for SIEMENS 'CSA Non Image'      
      {
      
         gdcmWarningMacro( " -------------------------------------------"
              << "a PRIVATE SQItem was found : " << v);
         si = DicomDirPrivate::New(true);  // true = empty
         if ( !AddPrivateToEnd( static_cast<DicomDirPrivate *>(si)) )
         {
            si->Delete();
            si = NULL;
            gdcmErrorMacro( "Add PrivateToEnd failed");
         }
      }      
      else
      {
         // It was neither a 'PATIENT', nor a 'STUDY', nor a 'SERIE',
         // nor an 'IMAGE' SQItem. Skip to next item.
         gdcmWarningMacro( " -------------------------------------------"
         << "a non PATIENT/STUDY/SERIE/IMAGE /VISIT/PRIVATE SQItem was found : "
         << v);

        // FIXME : deal with other item types !
        tmpSI=s->GetNextSQItem(); // To avoid infinite loop
        continue;
      }
      if ( si )
         si->Copy(tmpSI);

      tmpSI=s->GetNextSQItem();
   }
   ClearEntry();
}

bool DicomDir::AddPatientToEnd(DicomDirPatient *dd)
{
   Patients.push_back(dd);
   return true;
}

bool DicomDir::AddStudyToEnd(DicomDirStudy *dd)
{
   if ( Patients.size() > 0 )
   {
      ListDicomDirPatient::iterator itp = Patients.end();
      itp--;
      (*itp)->AddStudy(dd);
      return true;
   }
   return false;
}

bool DicomDir::AddSerieToEnd(DicomDirSerie *dd)
{
   if ( Patients.size() > 0 )
   {
      ListDicomDirPatient::iterator itp = Patients.end();
      itp--;

      DicomDirStudy *study = (*itp)->GetLastStudy();
      if ( study )
      {
         study->AddSerie(dd);
         return true;
      }
   }
   return false;
}

bool DicomDir::AddVisitToEnd(DicomDirVisit *dd)
{
   if ( Patients.size() > 0 )
   {
      ListDicomDirPatient::iterator itp = Patients.end();
      itp--;

      DicomDirStudy *study = (*itp)->GetLastStudy();
      if ( study )
      {
         study->AddVisit(dd);
         return true;
      }
   }
   return false;
}
bool DicomDir::AddImageToEnd(DicomDirImage *dd)
{
   if ( Patients.size() > 0 )
   {
      ListDicomDirPatient::iterator itp = Patients.end();
      itp--;

      DicomDirStudy *study = (*itp)->GetLastStudy();
      if ( study )
      {
         DicomDirSerie *serie = study->GetLastSerie();
         if ( serie )
         {
            serie->AddImage(dd);
            return true;
         }
      }
   }
   return false;
}

bool DicomDir::AddPrivateToEnd(DicomDirPrivate *dd)
{
   if ( Patients.size() > 0 )
   {
      ListDicomDirPatient::iterator itp = Patients.end();
      itp--;

      DicomDirStudy *study = (*itp)->GetLastStudy();
      if ( study )
      {
         DicomDirSerie *serie = study->GetLastSerie();
         if ( serie )
         {
            serie->AddPrivate(dd);
            return true;
         }
      }
   }
   return false;
}

void DicomDir::SetElements(std::string const &path, VectDocument const &list)
{
   ClearEntry();
   ClearPatient();

   std::string patPrevName         = "", patPrevID  = "";
   std::string studPrevInstanceUID = "", studPrevID = "";
   std::string serPrevInstanceUID  = "", serPrevID  = "";

   std::string patCurName,         patCurID;
   std::string studCurInstanceUID, studCurID;
   std::string serCurInstanceUID,  serCurID;

   bool first = true;
   for( VectDocument::const_iterator it = list.begin();
                                     it != list.end(); 
                                   ++it )
   {
      // get the current file characteristics
      patCurName         = (*it)->GetEntryString(0x0010,0x0010);
      patCurID           = (*it)->GetEntryString(0x0010,0x0011);
      studCurInstanceUID = (*it)->GetEntryString(0x0020,0x000d);
      studCurID          = (*it)->GetEntryString(0x0020,0x0010);
      serCurInstanceUID  = (*it)->GetEntryString(0x0020,0x000e);
      serCurID           = (*it)->GetEntryString(0x0020,0x0011);

      if ( patCurName != patPrevName || patCurID != patPrevID || first )
      {
         SetElement(path, GDCM_DICOMDIR_PATIENT, *it);
         first = true;
      }

      // if new Study, deal with 'STUDY' Elements   
      if ( studCurInstanceUID != studPrevInstanceUID || studCurID != studPrevID 
         || first )
      {
         SetElement(path, GDCM_DICOMDIR_STUDY, *it);
         first = true;
      }

      // if new Serie, deal with 'SERIE' Elements   
      if ( serCurInstanceUID != serPrevInstanceUID || serCurID != serPrevID
         || first )
      {
         SetElement(path, GDCM_DICOMDIR_SERIE, *it);
      }
      
      // Always Deal with 'IMAGE' Elements  
      SetElement(path, GDCM_DICOMDIR_IMAGE, *it);

      patPrevName         = patCurName;
      patPrevID           = patCurID;
      studPrevInstanceUID = studCurInstanceUID;
      studPrevID          = studCurID;
      serPrevInstanceUID  = serCurInstanceUID;
      serPrevID           = serCurID;
      first = false;
   }
}

void DicomDir::SetElement(std::string const &path, DicomDirType type,
                          Document *header)
{
   ListDicomDirElem elemList;
   ListDicomDirElem::const_iterator it;
   uint16_t tmpGr, tmpEl;
   //DictEntry *dictEntry;
   DataEntry *entry;
   std::string val;
   SQItem *si;
   switch( type )
   {
      case GDCM_DICOMDIR_IMAGE:
         elemList = Global::GetDicomDirElements()->GetDicomDirImageElements();
         si = DicomDirImage::New(true);
         if ( !AddImageToEnd(static_cast<DicomDirImage *>(si)) )
         {
            si->Delete();
            gdcmErrorMacro( "Add ImageToEnd failed");
         }
         break;
      case GDCM_DICOMDIR_SERIE:
         elemList = Global::GetDicomDirElements()->GetDicomDirSerieElements();
         si = DicomDirSerie::New(true);
         if ( !AddSerieToEnd(static_cast<DicomDirSerie *>(si)) )
         {
            si->Delete();
            gdcmErrorMacro( "Add SerieToEnd failed");
         }
         break;
      case GDCM_DICOMDIR_STUDY:
         elemList = Global::GetDicomDirElements()->GetDicomDirStudyElements();
         si = DicomDirStudy::New(true);
         if ( !AddStudyToEnd(static_cast<DicomDirStudy *>(si)) )
         {
            si->Delete();
            gdcmErrorMacro( "Add StudyToEnd failed");
         }
         break;
      case GDCM_DICOMDIR_PATIENT:
         elemList = Global::GetDicomDirElements()->GetDicomDirPatientElements();
         si = DicomDirPatient::New(true);
         if ( !AddPatientToEnd(static_cast<DicomDirPatient *>(si)) )
         {
            si->Delete();
            gdcmErrorMacro( "Add PatientToEnd failed");
         }
         break;
      case GDCM_DICOMDIR_META:  // never used ?!? --> Done within DoTheLoadingJob
         if ( MetaElems )
         {
            MetaElems->Delete();
            gdcmErrorMacro( "MetaElements already exist, they will be destroyed");
         }
         elemList = Global::GetDicomDirElements()->GetDicomDirMetaElements();
         MetaElems = DicomDirMeta::New(true);
         si = MetaElems;
         break;
      default:
         return;
   }

   // FIXME : troubles found when it's a SeqEntry

   // removed all the seems-to-be-useless stuff about Referenced Image Sequence
   // to avoid further troubles
   // imageElem 0008 1140 "" // Referenced Image Sequence
   // imageElem fffe e000 "" // 'no length' item : length to be set to 0xffffffff later
   // imageElem 0008 1150 "" // Referenced SOP Class UID    : to be set/forged later
   // imageElem 0008 1155 "" // Referenced SOP Instance UID : to be set/forged later
   // imageElem fffe e00d "" // Item delimitation : length to be set to ZERO later
 
   std::string referencedVal;
   // for all the relevant elements found in their own spot of the DicomDir.dic
   for( it = elemList.begin(); it != elemList.end(); ++it)
   {
      tmpGr     = it->Group;
      tmpEl     = it->Elem;
       
      entry     = DataEntry::New(tmpGr, tmpEl, it->VR); // dicomelements file was modified, to store VR
      entry->SetOffset(0); // just to avoid further missprinting

      if ( header )
      {
         // NULL when we Build Up (ex nihilo) a DICOMDIR
         //   or when we add the META elems
         val = header->GetEntryString(tmpGr, tmpEl); 
      }
      else
      {
         val = GDCM_UNFOUND;
      }

      if ( val == GDCM_UNFOUND) 
      {
         if ( tmpGr == 0x0004 ) // never present in File !     
         {
            switch (tmpEl)
            {
            case 0x1130: // File-set ID
               // force to the *end* File Name
               val = Util::GetName( path );
               break;
      
            case 0x1500: // Only used for image    
               if ( header->GetFileName().substr(0, path.length()) != path )
               { 
                 gdcmWarningMacro( "The base path of file name is incorrect");
                 val = header->GetFileName();
               }
               else
               { 
                 // avoid the first '/' in File name !
                 if ( header->GetFileName().c_str()[path.length()] 
                                                      == GDCM_FILESEPARATOR )
                    val = &(header->GetFileName().c_str()[path.length()+1]);
                 else  
                    val = &(header->GetFileName().c_str()[path.length()]);   
               }
               break;
    
             case 0x1510:  // Referenced SOP Class UID in File
               referencedVal = header->GetEntryString(0x0008, 0x0016);
               // FIXME : probabely something to check
               val = referencedVal;
               break;
       
             case 0x1511: // Referenced SOP Instance UID in File
               referencedVal = header->GetEntryString(0x0008, 0x0018);
               // FIXME : probabely something to check
               val = referencedVal;
               break;
    
            case 0x1512: // Referenced Transfer Syntax UID in File
               referencedVal = header->GetEntryString(0x0002, 0x0010);
               // FIXME : probabely something to check
               val = referencedVal;
               break;
    
            default :
               val = it->Value;   
            } 
         }
         else
         {
            // If the entry is not found in the Header, don't write its 'value' in the DICOMDIR !
            entry->Delete();
            continue;
          }
      }
      else
      {
         if ( header->GetEntryLength(tmpGr,tmpEl) == 0 )
         {
            val = it->Value;
            // Don't polute the DICOMDIR with empty fields
            if (val == "")
            {
               entry->Delete();
               continue;
            }  
         }    
      }

/* FIX later the pb of creating the 'Implementation Version Name'!

      if (val == GDCM_UNFOUND)
         val = "";

      if ( tmpGr == 0x0002 && tmpEl == 0x0013)
      { 
         // 'Implementation Version Name'
         std::string val = "GDCM ";
         val += Util::GetVersion();
      }
*/ 

      entry->SetString( val ); // troubles expected when vr=SQ ...

      if ( type == GDCM_DICOMDIR_META ) // fusible : should never print !
      {
         gdcmDebugMacro("GDCM_DICOMDIR_META ?!? should never print that");
      }
      
      si->AddEntry(entry);
      entry->Delete();
   }
}

void DicomDir::MoveSQItem(DocEntrySet *dst, DocEntrySet *src)
{ 
   DocEntry *entry;
// todo : rewrite the whole stuff, without using RemoveEntry an AddEntry,
//        to save time
   entry = src->GetFirstEntry();
   while(entry)
   {
      dst->AddEntry(entry);  // use it, *before* removing it!
      src->RemoveEntry(entry);
      // we destroyed -> the current iterator is not longer valid
      entry = src->GetFirstEntry();
   }
}

bool DicomDir::HeaderLessThan(Document *header1, Document *header2)
{
   return *header1 < *header2;
}

//-----------------------------------------------------------------------------
// Print
void DicomDir::Print(std::ostream &os, std::string const & )
{
   if ( MetaElems )
   {
      MetaElems->SetPrintLevel(PrintLevel);
      MetaElems->Print(os);   
   }   
   for(ListDicomDirPatient::iterator cc  = Patients.begin();
                                     cc != Patients.end();
                                   ++cc)
   {
     (*cc)->SetPrintLevel(PrintLevel);
     (*cc)->Print(os);
   }
}

//-----------------------------------------------------------------------------
} // end namespace gdcm

---