]> Creatis software - gdcm.git/blob - src/gdcmSQItem.cxx
b63b376a44d153d512b895742fd5cb6f9be9c9b6
[gdcm.git] / src / gdcmSQItem.cxx
1 /*=========================================================================
2   
3   Program:   gdcm
4   Module:    $RCSfile: gdcmSQItem.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/01/24 16:44:54 $
7   Version:   $Revision: 1.58 $
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 "gdcmSQItem.h"
20 #include "gdcmSeqEntry.h"
21 #include "gdcmValEntry.h"
22 #include "gdcmBinEntry.h"
23 #include "gdcmGlobal.h"
24 #include "gdcmDictSet.h"
25 #include "gdcmUtil.h"
26 #include "gdcmDebug.h"
27
28 #include <fstream>
29
30 namespace gdcm 
31 {
32 //-----------------------------------------------------------------------------
33 // Constructor / Destructor
34 /**
35  * \brief   Constructor from a given SQItem
36  */
37 SQItem::SQItem(int depthLevel ) 
38           : DocEntrySet( )
39 {
40    SQDepthLevel = depthLevel;
41 }
42
43 /**
44  * \brief   Canonical destructor.
45  */
46 SQItem::~SQItem() 
47 {
48    for(ListDocEntry::iterator cc = DocEntries.begin();
49                              cc != DocEntries.end();
50                              ++cc)
51    {
52       delete *cc;
53    }
54    DocEntries.clear();
55 }
56
57 //-----------------------------------------------------------------------------
58 // Print
59 /*
60  * \brief   canonical Printer
61  * @param os     Stream to print to. 
62  * @param indent Indentation string to be prepended during printing.
63  */
64 void SQItem::Print(std::ostream &os, std::string const &)
65 {
66    std::ostringstream s;
67
68    if (SQDepthLevel > 0)
69    {
70       for (int i = 0; i < SQDepthLevel; ++i)
71       {
72          s << "   | " ;
73       }
74    }
75    os << s.str() << " --- SQItem number " << SQItemNumber  << std::endl;
76    for (ListDocEntry::iterator i  = DocEntries.begin();
77                                i != DocEntries.end();
78                              ++i)
79    {
80       DocEntry *Entry = *i;
81       bool PrintEndLine = true;
82
83       os << s.str();
84       Entry->SetPrintLevel(PrintLevel);
85       Entry->Print(os); 
86       if ( dynamic_cast<SeqEntry*>(Entry) )
87       {
88          PrintEndLine = false;
89       }
90       if (PrintEndLine)
91       {
92          os << std::endl;
93       }
94    } 
95 }
96
97 /*
98  * \brief   canonical Writer
99  * @param fp     file pointer to an already open file. 
100  * @param filetype type of the file (ACR, ImplicitVR, ExplicitVR, ...)
101  */
102 void SQItem::WriteContent(std::ofstream *fp, FileType filetype)
103 {
104    int j;
105    uint16_t item[4] = { 0xfffe, 0xe000, 0xffff, 0xffff };
106    uint16_t itemt[4]= { 0xfffe, 0xe00d, 0xffff, 0xffff };
107
108     //we force the writting of an 'Item' Start Element
109     // because we want to write the Item as a 'no Length' item
110    for(j=0;j<4;++j)
111    {
112       binary_write( *fp, item[j]);  // fffe e000 ffff ffff 
113    }
114      
115    for (ListDocEntry::iterator it = DocEntries.begin();  
116                               it != DocEntries.end();
117                              ++it)
118    {   
119       // we skip delimitors (start and end one) because 
120       // we force them as 'no length'
121       if ( (*it)->GetGroup() == 0xfffe )
122       {
123          continue;
124       }
125
126       // Fix in order to make some MR PHILIPS images e-film readable
127       // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
128       // we just *always* ignore spurious fffe|0000 tag ! 
129       if ( (*it)->GetGroup() == 0xfffe && (*it)->GetElement() == 0x0000 )
130       {
131          break; // FIXME : continue; ?!?
132       }
133
134       (*it)->WriteContent(fp, filetype);
135    }
136       
137     //we force the writting of an 'Item Delimitation' item
138     // because we wrote the Item as a 'no Length' item
139    for(j=0;j<4;++j)
140    {
141       binary_write( *fp, itemt[j]);  // fffe e000 ffff ffff 
142    }
143  
144 }
145
146 //-----------------------------------------------------------------------------
147 // Public
148 /**
149  * \brief   adds any Entry (Dicom Element) to the Sequence Item
150  * @param entry Entry to add
151  */
152 bool SQItem::AddEntry(DocEntry *entry)
153 {
154    DocEntries.push_back(entry);
155    //TODO : check if it worked
156    return true;
157 }   
158
159 /**
160  * \brief   Sets Entry (Dicom Element) value of an element,
161  *          specified by it's tag (Group, Number) 
162  *          and the length, too ...  inside a SQ Item
163  *          If the Element is not found, it's just created !
164  * \warning we suppose, right now, the element belongs to a Public Group
165  *          (NOT a shadow one)       
166  * @param   val string value to set
167  * @param   group  Group number of the searched tag.
168  * @param   elem Element number of the searched tag.
169  * @return  true if element was found or created successfully
170  */
171
172 bool SQItem::SetEntryValue(std::string const &val, uint16_t group, 
173                       uint16_t elem)
174 {
175    for(ListDocEntry::iterator i = DocEntries.begin(); 
176                               i != DocEntries.end(); 
177                             ++i)
178    { 
179       if ( (*i)->GetGroup() == 0xfffe && (*i)->GetElement() == 0xe000 ) 
180       {
181          continue;
182       }
183
184       if (  ( group  < (*i)->GetGroup() )
185           ||( group == (*i)->GetGroup() && elem < (*i)->GetElement()) )
186       {
187          // instead of Insert, that is a method of Document :-( 
188          ValEntry* entry = 0;
189          TagKey key = DictEntry::TranslateToKey(group, elem);
190
191          // we assume a Public Dictionary *is* loaded
192          Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
193          // if the invoked (group,elem) doesn't exist inside the Dictionary
194          // we create a VirtualDictEntry
195          DictEntry *dictEntry = pubDict->GetEntry(group, elem);
196          if (dictEntry == NULL)
197          {
198             dictEntry = 
199                Global::GetDicts()->NewVirtualDictEntry(group, elem,
200                                                        "UN", GDCM_UNKNOWN, 
201                                                         GDCM_UNKNOWN);
202          } 
203          // we assume the constructor didn't fail
204          entry = new ValEntry(dictEntry);
205          if (entry)
206          {
207             entry->SetValue(val); 
208          }
209          DocEntries.insert(i,entry);
210
211          return true;
212       }   
213       if (group == (*i)->GetGroup() && elem == (*i)->GetElement() )
214       {
215          if ( ValEntry *entry = dynamic_cast<ValEntry*>(*i) )
216          {
217             entry->SetValue(val);
218          }
219          return true;    
220       }
221    }
222    return false;
223 }
224
225 /**
226  * \brief   Clear the std::list from given entry AND delete the entry.
227  * @param   entryToRemove Entry to remove AND delete.
228  * @return true if the entry was found and removed; false otherwise
229  */
230 bool SQItem::RemoveEntry( DocEntry* entryToRemove)
231 {
232    for(ListDocEntry::iterator it = DocEntries.begin();
233        it != DocEntries.end();
234        ++it)
235    {
236       if( *it == entryToRemove)
237       {
238          DocEntries.erase(it);
239          gdcmVerboseMacro( "One element erased: " << entryToRemove->GetKey() );
240          delete entryToRemove;
241          return true;
242       }
243    }
244    gdcmVerboseMacro( "Entry not found: " << entryToRemove->GetKey() );
245    return false ;
246 }
247
248 /**
249  * \brief   Clear the std::list from given entry BUT keep the entry.
250  * @param   entryToRemove Entry to remove.
251  * @return true if the entry was found and removed; false otherwise
252  */
253 bool SQItem::RemoveEntryNoDestroy(DocEntry* entryToRemove)
254 {
255    for(ListDocEntry::iterator it = DocEntries.begin();
256        it != DocEntries.end();
257        ++it)
258    {
259       if( *it == entryToRemove)
260       {
261          DocEntries.erase(it);
262          gdcmVerboseMacro( "One element erased, no destroyed: "
263                             << entryToRemove->GetKey() );
264          return true;
265       }
266    }
267                                                                                 
268    gdcmVerboseMacro( "Entry not found:" << entryToRemove->GetKey() );
269    return false ;
270 }
271                                                                                 
272 /**
273  * \brief   Get the first Dicom entry while visiting the SQItem
274  * \return  The first DocEntry if found, otherwhise 0
275  */
276 DocEntry * SQItem::GetFirstEntry()
277 {
278    ItDocEntries = DocEntries.begin();
279    if (ItDocEntries != DocEntries.end())
280       return *ItDocEntries;
281    return 0;   
282 }
283                                                                                 
284 /**
285  * \brief   Get the next Dicom entry while visiting the chained list
286  * \return  The next DocEntry if found, otherwhise NULL
287  */
288 DocEntry *SQItem::GetNextEntry()
289 {
290   // gdcmAssertMacro (ItDocEntries != DocEntries.end());
291    {
292       ++ItDocEntries;
293       if (ItDocEntries != DocEntries.end())
294          return  *ItDocEntries;
295       return NULL;
296    }
297 }
298
299 //-----------------------------------------------------------------------------
300 // Protected
301 /**
302  * \brief   Gets a Dicom Element inside a SQ Item Entry
303  * @param   group Group number of the Entry
304  * @param   elem  Element number of the Entry
305  * @return Entry whose (group,elem) was passed. 0 if not found
306  */
307 DocEntry *SQItem::GetDocEntry(uint16_t group, uint16_t elem)
308 {
309    for(ListDocEntry::iterator i = DocEntries.begin();
310                               i != DocEntries.end(); ++i)
311    {
312       if ( (*i)->GetGroup() == group && (*i)->GetElement() == elem )
313       {
314          return *i;
315       }
316    }
317    return 0;
318 }
319
320 /**
321  * \brief   Gets a Dicom Element inside a SQ Item Entry
322  * @param   group Group number of the Entry
323  * @param   elem  Element number of the Entry
324  * @return Entry whose (group,elem) was passed. 0 if not found
325  */
326 ValEntry* SQItem::GetValEntry(uint16_t group, uint16_t elem)
327 {
328    DocEntry *d = GetDocEntry(group, elem);
329    if ( ValEntry *e = dynamic_cast<ValEntry*>(d) )
330       return e;
331    return 0;
332 }
333
334 /**
335  * \brief   Gets a Dicom Element inside a SQ Item Entry
336  * @param   group   Group number of the Entry
337  * @param   elem  Element number of the Entry
338  * @return Entry whose (group,elem) was passed. 0 if not found
339  */
340 BinEntry* SQItem::GetBinEntry(uint16_t group, uint16_t elem)
341 {
342    DocEntry *d = GetDocEntry(group, elem);
343    if ( BinEntry *e = dynamic_cast<BinEntry*>(d) )
344       return e;
345    return 0;
346 }
347
348 /**
349  * \brief   Gets a Dicom Element inside a SQ Item Entry
350  * @param   group   Group number of the Entry
351  * @param   elem  Element number of the Entry
352  * @return Entry whose (group,elem) was passed. 0 if not found
353  */
354 SeqEntry* SQItem::GetSeqEntry(uint16_t group, uint16_t elem)
355 {
356    DocEntry *d = GetDocEntry(group, elem);
357    if ( SeqEntry *e = dynamic_cast<SeqEntry*>(d) )
358       return e;
359    return 0;
360 }
361
362
363 /**
364  * \brief   Get the value of a Dicom Element inside a SQ Item Entry
365  * \note : meaningfull only if the required entry is NEITHER a SeqEntry 
366  *                                                   NOR a BinEntry
367  * @param   group   Group number of the Entry
368  * @param   elem  Element number of the Entry 
369  * @return  'string value' of the entry whose (group,elem) was passed.
370  *           GDCM_UNFOUND if not found
371  */ 
372
373 std::string SQItem::GetEntryValue(uint16_t group, uint16_t elem)
374 {
375
376 /*
377    DocEntry *e = GetFirstEntry();
378    while (e)
379    {
380       if ( e->GetGroup() == group && e->GetElement() == elem)
381       {
382
383          if (ValEntry *ve = dynamic_cast<ValEntry*>(e))
384             return ve->GetValue();
385       }
386       e = GetNextEntry();
387    }   
388 */
389    for(ListDocEntry::iterator i = DocEntries.begin();
390                               i != DocEntries.end(); ++i)
391    {
392       if ( (*i)->GetGroup() == group && (*i)->GetElement() == elem)
393       {
394          if (ValEntry *ve = dynamic_cast<ValEntry*>(*i))
395            return ve->GetValue();
396       }
397    }
398    return GDCM_UNFOUND;
399 }
400 //-----------------------------------------------------------------------------
401 // Private
402
403
404 //-----------------------------------------------------------------------------
405
406 } // end namespace gdcm