]> Creatis software - gdcm.git/blob - gdcmDocEntry.cxx
706d023c351865c50f1db532d8c6f947a60116e9
[gdcm.git] / gdcmDocEntry.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmDocEntry.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/11/21 12:15:06 $
7   Version:   $Revision: 1.78 $
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
33 // Constructor / Destructor
34 /**
35  * \brief   Constructor from a given DictEntry
36  * @param   in Pointer to existing dictionary entry
37  */
38 DocEntry::DocEntry(DictEntry *in)
39 {
40    ImplicitVR = false;
41    DicomDict  = in;
42    Offset     = 0 ; // To avoid further missprinting
43
44    // init some variables
45    ReadLength = 0;
46    Length = 0;
47
48    gdcmAssertMacro(DicomDict);
49    DicomDict->Register();
50 }
51
52 /**
53  * \brief   Destructor from a given DictEntry
54  */
55 DocEntry::~DocEntry()
56 {
57    gdcmAssertMacro(DicomDict);
58
59    DicomDict->Unregister();
60 }
61
62 //-----------------------------------------------------------------------------
63 // Public
64 /**
65  * \brief   Writes the common part of any DataEntry, SeqEntry
66  * @param fp already open ofstream pointer
67  * @param filetype type of the file (ACR, ImplicitVR, ExplicitVR, ...)
68  */
69 void DocEntry::WriteContent(std::ofstream *fp, FileType filetype)
70 {
71    uint32_t ffff  = 0xffffffff;
72    uint16_t group = GetGroup();
73    VRKey vr       = GetVR();
74    uint16_t el    = GetElement();
75    uint32_t lgth  = GetLength();
76
77    if ( group == 0xfffe && el == 0x0000 )
78    {
79      // Fix in order to make some MR PHILIPS images e-film readable
80      // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
81      // we just *always* ignore spurious fffe|0000 tag !   
82       return;
83    }
84    //
85    // ----------- Writes the common part
86    //
87     // To avoid gdcm to propagate oddities.
88     // --> Don't forget to *write* an even length value   
89    if (lgth%2)
90       lgth ++;
91    
92  // ----------- Writes the common part : the Tag   
93    binary_write( *fp, group); //group number
94    binary_write( *fp, el);    //element number
95
96    // Dicom V3 group 0x0002 is *always* Explicit VR !
97    if ( filetype == ExplicitVR || filetype == JPEG || group == 0x0002 )
98    {
99
100 // ----------- Writes the common part : the VR + the length 
101   
102           // Special case of delimiters:
103       if (group == 0xfffe)
104       {
105          // Delimiters have NO Value Representation
106          // Hence we skip writing the VR.
107          //
108          // In order to avoid further troubles, we choose to write them
109          // as 'no-length' Item Delimitors (we pad by writing 0xffffffff)
110          // We shall force the end of a given SeqItem by writting 
111          //  a Item Delimitation Item (fffe, e00d)
112
113          uint32_t ff = 0xffffffff;
114          binary_write(*fp, ff);
115          return;
116       }
117
118       uint16_t zero = 0;
119       uint16_t shortLgr = (uint16_t)lgth;
120
121       if( IsVRUnknown() )
122       {
123          // GDCM_VRUNKNOWN was stored in the Entry VR;
124          // deal with Entry as if TS were Implicit VR
125  
126          binary_write(*fp, lgth);
127       }
128       else
129       {
130          binary_write(*fp, vr.str());
131
132          // See PS 3.5-2004 page 33, 36                  
133          if ( (vr == "SQ") || (vr == "OB") || (vr == "OW") || (vr == "OF") 
134           ||  (vr == "UN") || (vr == "UT") )
135          {
136             binary_write(*fp, zero);
137             if (vr == "SQ")
138             {
139                // we set SQ length to ffffffff
140                // and  we shall write a Sequence Delimitor Item 
141                // at the end of the Sequence! 
142                binary_write(*fp, ffff);
143             }
144             else
145             {
146                binary_write(*fp, lgth);
147             }
148          }
149          else
150          {
151             binary_write(*fp, shortLgr);
152          }
153       }
154    } 
155    else // IMPLICIT VR 
156    { 
157 // ----------- Writes the common part : the VR  
158       if (vr == "SQ")
159       {
160          binary_write(*fp, ffff);
161       }
162       else
163       {
164          binary_write(*fp, lgth);
165       }
166    }
167 }
168
169 /**
170  * \brief   Gets the full length of the elementary DocEntry (not only value
171  *          length) depending on the VR.
172  */
173 uint32_t DocEntry::GetFullLength()
174 {
175    uint32_t l = GetReadLength();
176    if ( IsImplicitVR() )
177    {
178       l = l + 8;  // 2 (gr) + 2 (el) + 4 (lgth) 
179    }
180    else
181    {
182       if ( GetVR()=="OB" || GetVR()=="OW" || GetVR()=="SQ" )
183       {
184          l = l + 12; // 2 (gr) + 2 (el) + 2 (vr) + 2 (unused) + 4 (lgth)
185       }
186       else
187       {
188          l = l + 8;  // 2 (gr) + 2 (el) + 2 (vr) + 2 (lgth)
189       }
190    }
191    return l;
192 }
193
194 /**
195  * \brief   tells us if entry is the last one of a 'no length' SequenceItem 
196  *          (fffe,e00d) 
197  */
198 bool DocEntry::IsItemDelimitor()
199 {
200    return (GetGroup() == 0xfffe && GetElement() == 0xe00d);
201 }
202
203 /**
204  * \brief   tells us if entry is the first one of an Item 
205  *          (fffe,e000) 
206  */
207 bool DocEntry::IsItemStarter()
208 {
209    return (GetGroup() == 0xfffe && GetElement() == 0xe000);
210 }
211
212 /**
213  * \brief   tells us if entry is the last one of a 'no length' Sequence 
214  *          (fffe,e0dd) 
215  */
216 bool DocEntry::IsSequenceDelimitor()
217 {
218    return (GetGroup() == 0xfffe && GetElement() == 0xe0dd);
219 }
220
221 /**
222  * \brief   Copies all the attributes from an other DocEntry 
223  * @param doc entry to copy from
224  */
225 void DocEntry::Copy(DocEntry *doc)
226 {
227    Length     = doc->Length;
228    ReadLength = doc->ReadLength;
229    ImplicitVR = doc->ImplicitVR;
230    Offset     = doc->Offset;
231 }
232
233 //-----------------------------------------------------------------------------
234 // Protected
235
236 //-----------------------------------------------------------------------------
237 // Private
238
239 //-----------------------------------------------------------------------------
240 // Print
241 /**
242  * \brief   Prints the common part of DataEntry, SeqEntry
243  * @param   os ostream we want to print in
244  * @param indent Indentation string to be prepended during printing
245  */
246 void DocEntry::Print(std::ostream &os, std::string const & )
247 {
248    size_t o;
249    std::string st;
250    TSKey v;
251    std::string d2;
252    VRKey vr;
253    std::ostringstream s;
254    uint32_t lgth;
255
256    o  = GetOffset();
257    vr = GetVR();
258    if ( vr == GDCM_VRUNKNOWN )
259       vr = "  ";
260
261    s << DictEntry::TranslateToKey(GetGroup(),GetElement()); 
262
263    if (PrintLevel >= 2)
264    {
265       s << " lg : ";
266       lgth = GetReadLength(); // ReadLength, as opposed to (usable) Length
267       if (lgth == 0xffffffff)
268       {
269          st = " ffff ";
270          s.setf(std::ios::left);
271          s << std::setw(4);  
272          s << "    x(ffff) ";
273          s.setf(std::ios::left);
274          s << std::setw(8) << "-1"; 
275       }
276       else
277       {
278          st = Util::Format("x(%x)",lgth); // we may keep it
279          s.setf(std::ios::left);
280          s << std::setw(11-st.size()) << " ";
281          s << st << " ";
282          s.setf(std::ios::left);
283          s << std::setw(8) << lgth; 
284       }
285       s << " Off.: ";
286       st = Util::Format("x(%x)",o);  // we may keep it
287       s << std::setw(11-st.size()) << " ";
288       s << st << " ";
289       s << std::setw(8) << o; 
290    }
291    if (PrintLevel >= 1)
292       s << " ";
293
294    s << "[" << vr  << "] ";
295
296    std::string name;
297    if ( GetElement() == 0x0000 )
298       name = "Group Length";
299    else
300       name = GetName();
301
302    if (PrintLevel >= 1)
303    {
304       s.setf(std::ios::left);
305       s << std::setw(66-name.length()) << " ";
306    }
307     
308    s << "[" << name << "]";
309    os << s.str();      
310 }
311
312 //-----------------------------------------------------------------------------
313 } // end namespace gdcm