]> Creatis software - gdcm.git/blob - src/gdcmDocEntry.cxx
75b832796edd6507b153bee3c9c85af8bf9f7e2f
[gdcm.git] / src / gdcmDocEntry.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmDocEntry.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/01/18 14:28:32 $
7   Version:   $Revision: 1.43 $
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 "gdcmDocEntry.h"
20 #include "gdcmTS.h"
21 #include "gdcmVR.h"
22 #include "gdcmGlobal.h"
23 #include "gdcmUtil.h"
24 #include "gdcmDebug.h"
25
26 #include <iomanip> // for std::ios::left, ...
27 #include <fstream>
28
29 namespace gdcm 
30 {
31
32 // CLEAN ME
33 #define MAX_SIZE_PRINT_ELEMENT_VALUE 64
34
35 //-----------------------------------------------------------------------------
36 // Constructor / Destructor
37 /**
38  * \brief   Constructor from a given DictEntry
39  * @param   in Pointer to existing dictionary entry
40  */
41 DocEntry::DocEntry(DictEntry *in)
42 {
43    ImplicitVR = false;
44    DicomDict  = in;
45    SetKey( in->GetKey( ) );
46    Offset     = 0 ; // To avoid further missprinting
47
48    // init some variables
49    ReadLength = 0;
50    Length = 0;
51 }
52
53 //-----------------------------------------------------------------------------
54 // Print
55 /**
56  * \brief   Prints the common part of ValEntry, BinEntry, SeqEntry
57  * @param   os ostream we want to print in
58  * @param indent Indentation string to be prepended during printing
59  */
60 void DocEntry::Print(std::ostream &os, std::string const & )
61 {
62    size_t o;
63    std::string st;
64    TSKey v;
65    std::string d2, vr;
66    std::ostringstream s;
67    uint32_t lgth;
68
69    o  = GetOffset();
70    vr = GetVR();
71    if(vr==GDCM_UNKNOWN)
72       vr="  ";
73
74    s << DictEntry::TranslateToKey(GetGroup(),GetElement()); 
75
76    if (PrintLevel >= 2)
77    {
78       s << " lg : ";
79       lgth = GetReadLength(); // ReadLength, as opposed to Length
80       if (lgth == 0xffffffff)
81       {
82          st = Util::Format("x(ffff)");  // I said : "x(ffff)" !
83          s.setf(std::ios::left);
84          s << std::setw(10-st.size()) << " ";  
85          s << st << " ";
86          s.setf(std::ios::left);
87          s << std::setw(8) << "-1"; 
88       }
89       else
90       {
91          st = Util::Format("x(%x)",lgth);
92          s.setf(std::ios::left);
93          s << std::setw(10-st.size()) << " ";
94          s << st << " ";
95          s.setf(std::ios::left);
96          s << std::setw(8) << lgth; 
97       }
98       s << " Off.: ";
99       st = Util::Format("x(%x)",o); 
100       s << std::setw(10-st.size()) << " ";
101       s << st << " ";
102       s << std::setw(8) << o; 
103    }
104
105    s << "[" << vr  << "] ";
106
107    if (PrintLevel >= 1)
108    {
109       s.setf(std::ios::left);
110       s << std::setw(66-GetName().length()) << " ";
111    }
112     
113    s << "[" << GetName()<< "]";
114    os << s.str();      
115 }
116
117 /**
118  * \brief   Writes the common part of any ValEntry, BinEntry, SeqEntry
119  * @param fp already open file pointer
120  * @param filetype type of the file to be written
121  */
122 void DocEntry::WriteContent(std::ofstream *fp, FileType filetype)
123 {
124    uint32_t ffff  = 0xffffffff;
125    uint16_t group = GetGroup();
126    VRKey vr   = GetVR();
127    uint16_t el    = GetElement();
128    uint32_t lgr   = GetLength();
129
130    if ( group == 0xfffe && el == 0x0000 )
131    {
132      // Fix in order to make some MR PHILIPS images e-film readable
133      // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
134      // we just *always* ignore spurious fffe|0000 tag !   
135       return;
136    }
137
138    //
139    // ----------- Writes the common part
140    //
141    binary_write( *fp, group);  //group
142    binary_write( *fp, el);  //element
143
144    if ( filetype == ExplicitVR )
145    {
146       // Special case of delimiters:
147       if (group == 0xfffe)
148       {
149          // Delimiters have NO Value Representation
150          // Hence we skip writing the VR.
151          // In order to avoid further troubles, we choose to write them
152          // as 'no-length' Item Delimitors (we pad by writing 0xffffffff)
153          // The end of a given Item will be found when  :
154          //  - a new Item Delimitor Item is encountered (the Seq goes on)
155          //  - a Sequence Delimitor Item is encountered (the Seq just ended)
156
157          // TODO : verify if the Sequence Delimitor Item was forced during Parsing 
158
159          uint32_t ff = 0xffffffff;
160          binary_write(*fp, ff);
161          return;
162       }
163
164       uint16_t z = 0;
165       uint16_t shortLgr = lgr;
166
167       if (vr == GDCM_UNKNOWN)
168       {
169          // Unknown was 'written'
170          // deal with Little Endian            
171          binary_write(*fp, shortLgr);
172          binary_write(*fp, z);
173       }
174       else
175       {
176          binary_write(*fp, vr);
177          gdcmAssertMacro( vr.size() == 2 );
178                   
179          if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || (vr == "UN") )
180          {
181             binary_write(*fp, z);
182             if (vr == "SQ")
183             {
184                // we set SQ length to ffffffff
185                // and  we shall write a Sequence Delimitor Item 
186                // at the end of the Sequence! 
187                binary_write(*fp, ffff);
188             }
189             else
190             {
191                binary_write(*fp, lgr);
192             }
193          }
194          else
195          {
196             binary_write(*fp, shortLgr);
197          }
198       }
199    } 
200    else // IMPLICIT VR 
201    { 
202       if (vr == "SQ")
203       {
204          binary_write(*fp, ffff);
205       }
206       else
207       {
208          binary_write(*fp, lgr);
209       }
210    }
211 }
212
213 //-----------------------------------------------------------------------------
214 // Public
215
216 /**
217  * \brief   Gets the full length of the elementary DocEntry (not only value
218  *          length) depending on the VR.
219  */
220 uint32_t DocEntry::GetFullLength()
221 {
222    uint32_t l = GetReadLength();
223    if ( IsImplicitVR() )
224    {
225       l = l + 8;  // 2 (gr) + 2 (el) + 4 (lgth) 
226    }
227    else
228    {
229       if ( GetVR()=="OB" || GetVR()=="OW" || GetVR()=="SQ" )
230       {
231          l = l + 12; // 2 (gr) + 2 (el) + 2 (vr) + 2 (unused) + 4 (lgth)
232       }
233       else
234       {
235          l = l + 8;  // 2 (gr) + 2 (el) + 2 (vr) + 2 (lgth)
236       }
237    }
238    return l;
239 }
240
241 /**
242  * \brief   Copies all the attributes from an other DocEntry 
243  * @param e entry to copy from
244  */
245 void DocEntry::Copy (DocEntry *e)
246 {
247    Length     = e->Length;
248    ReadLength = e->ReadLength;
249    ImplicitVR = e->ImplicitVR;
250    Offset     = e->Offset;
251 }
252
253 /**
254  * \brief   tells us if entry is the last one of a 'no length' SequenceItem 
255  *          (fffe,e00d) 
256  */
257 bool DocEntry::IsItemDelimitor()
258 {
259    return (GetGroup() == 0xfffe && GetElement() == 0xe00d);
260 }
261 /**
262  * \brief   tells us if entry is the last one of a 'no length' Sequence 
263  *          (fffe,e0dd) 
264  */
265 bool DocEntry::IsSequenceDelimitor()
266 {
267    return (GetGroup() == 0xfffe && GetElement() == 0xe0dd);
268 }
269
270 //-----------------------------------------------------------------------------
271 // Protected
272
273
274 //-----------------------------------------------------------------------------
275 // Private
276
277 //-----------------------------------------------------------------------------
278
279 } // end namespace gdcm