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