]> Creatis software - gdcm.git/blob - src/gdcmDocEntrySet.cxx
BUG: Remove my previous hack now this is properly fixed in gdcmBinEntry by JPR
[gdcm.git] / src / gdcmDocEntrySet.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmDocEntrySet.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/02/05 01:37:08 $
7   Version:   $Revision: 1.54 $
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 #include "gdcmDocEntrySet.h"
19
20 #include "gdcmDebug.h"
21 #include "gdcmCommon.h"
22 #include "gdcmDictSet.h"
23 #include "gdcmGlobal.h"
24 #include "gdcmDocEntry.h"
25 #include "gdcmSeqEntry.h"
26 #include "gdcmValEntry.h"
27 #include "gdcmBinEntry.h"
28
29 namespace gdcm 
30 {
31 //-----------------------------------------------------------------------------
32 // Constructor / Destructor
33
34 //-----------------------------------------------------------------------------
35 // Public
36 /**
37  * \brief   Get the "std::string representable" value of the Dicom entry
38  * @param   group  Group number of the searched tag.
39  * @param   elem Element number of the searched tag.
40  * @return  Corresponding element value when it exists,
41  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
42  */
43 std::string DocEntrySet::GetEntryValue(uint16_t group, uint16_t elem)
44 {
45    ContentEntry *entry = dynamic_cast<ContentEntry *>(GetDocEntry(group,elem));
46    if( entry )
47       return entry->GetValue();
48    return GDCM_UNFOUND;
49 }
50
51 /**
52  * \brief   Gets (from Header) a 'non string' element value 
53  * @param group   group number of the Entry 
54  * @param elem  element number of the Entry
55  * @return Pointer to the 'non string' area
56  */
57 void *DocEntrySet::GetEntryBinArea(uint16_t group, uint16_t elem) 
58 {
59    BinEntry *entry = GetBinEntry(group, elem);
60    if( entry )
61       return entry->GetBinArea();
62    return 0;
63 }
64
65 /**
66  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
67  *          the public and private dictionaries 
68  *          for the value length of a given tag..
69  * @param   group  Group number of the searched tag.
70  * @param   elem Element number of the searched tag.
71  * @return  Corresponding element length; -2 if not found
72  */
73 int DocEntrySet::GetEntryLength(uint16_t group, uint16_t elem)
74 {
75    DocEntry *entry = GetDocEntry(group, elem);
76    if( entry )
77       return entry->GetLength();
78    return -1;
79 }
80
81 /**
82  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
83  *          the public [and private dictionaries] 
84  *          for the element value representation of a given tag..
85  *          Obtaining the VR (Value Representation) might be needed by caller
86  *          to convert the string typed content to caller's native type 
87  *          (think of C++ vs Python). The VR is actually of a higher level
88  *          of semantics than just the native C++ type.
89  * @param   group  Group number of the searched tag.
90  * @param   elem Element number of the searched tag.
91  * @return  Corresponding element value representation when it exists,
92  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
93  */
94 std::string DocEntrySet::GetEntryVR(uint16_t group, uint16_t elem)
95 {
96    DocEntry *entry = GetDocEntry(group, elem);
97    if( entry )
98       return entry->GetVR();
99    return GDCM_UNFOUND;
100 }
101
102 /**
103  * \brief  Same as \ref Document::GetDocEntry except it only
104  *         returns a result when the corresponding entry is of type
105  *         ValEntry.
106  * @param   group  Group number of the searched Dicom Element 
107  * @param   elem Element number of the searched Dicom Element  
108  * @return When present, the corresponding ValEntry. 
109  */
110 ValEntry *DocEntrySet::GetValEntry(uint16_t group, uint16_t elem)
111 {
112    DocEntry *currentEntry = GetDocEntry(group, elem);
113    if ( !currentEntry )
114       return NULL;
115
116    return dynamic_cast<ValEntry*>(currentEntry);
117 }
118
119 /**
120  * \brief  Same as \ref Document::GetDocEntry except it only
121  *         returns a result when the corresponding entry is of type
122  *         BinEntry.
123  * @param   group  Group number of the searched Dicom Element
124  * @param   elem Element number of the searched Dicom Element
125  * @return When present, the corresponding BinEntry. 
126  */
127 BinEntry *DocEntrySet::GetBinEntry(uint16_t group, uint16_t elem)
128 {
129    DocEntry *currentEntry = GetDocEntry(group, elem);
130    if ( !currentEntry )
131    {
132       gdcmWarningMacro( "No corresponding BinEntry " << std::hex << group <<
133                          "," << elem);
134       return NULL;
135    }
136
137    return dynamic_cast<BinEntry*>(currentEntry);
138 }
139
140 /**
141  * \brief  Same as \ref Document::GetDocEntry except it only
142  *         returns a result when the corresponding entry is of type
143  *         SeqEntry.
144  * @param   group  Group number of the searched Dicom Element 
145  * @param   elem Element number of the searched Dicom Element  
146  * @return When present, the corresponding SeqEntry. 
147  */
148 SeqEntry *DocEntrySet::GetSeqEntry(uint16_t group, uint16_t elem)
149 {
150    DocEntry *currentEntry = GetDocEntry(group, elem);
151    if ( !currentEntry )
152    {
153       gdcmWarningMacro( "No corresponding SeqEntry " << std::hex << group <<
154                         "," << elem);
155       return NULL;
156    }
157
158    return dynamic_cast<SeqEntry*>(currentEntry);
159 }
160
161 /**
162  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
163  *          through it's (group, element) and modifies it's content with
164  *          the given value.
165  * @param   content new value (string) to substitute with
166  * @param   group  group number of the Dicom Element to modify
167  * @param   elem element number of the Dicom Element to modify
168  */
169 bool DocEntrySet::SetValEntry(std::string const &content, 
170                               uint16_t group, uint16_t elem) 
171 {
172    ValEntry *entry = GetValEntry(group, elem);
173    if (!entry )
174    {
175       gdcmWarningMacro( "No corresponding ValEntry " << std::hex << group <<
176                          "," << elem << " element (try promotion first).");
177       return false;
178    }
179    return SetValEntry(content,entry);
180 }
181
182 /**
183  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
184  *          through it's (group, element) and modifies it's content with
185  *          the given value.
186  * @param   content new value (void*  -> uint8_t*) to substitute with
187  * @param   lgth new value length
188  * @param   group  group number of the Dicom Element to modify
189  * @param   elem element number of the Dicom Element to modify
190  */
191 bool DocEntrySet::SetBinEntry(uint8_t *content, int lgth, 
192                               uint16_t group, uint16_t elem) 
193 {
194    BinEntry *entry = GetBinEntry(group, elem);
195    if (!entry )
196    {
197       gdcmWarningMacro( "No corresponding ValEntry " << std::hex << group <<
198                         "," << elem << " element (try promotion first).");
199       return false;
200    }
201
202    return SetBinEntry(content,lgth,entry);
203
204
205 /**
206  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
207  *          and modifies it's content with the given value.
208  * @param  content new value (string) to substitute with
209  * @param  entry Entry to be modified
210  */
211 bool DocEntrySet::SetValEntry(std::string const &content, ValEntry *entry)
212 {
213    if(entry)
214    {
215       entry->SetValue(content);
216       return true;
217    }
218    return false;
219 }
220
221 /**
222  * \brief   Accesses an existing BinEntry (i.e. a Dicom Element)
223  *          and modifies it's content with the given value.
224  * @param   content new value (void*  -> uint8_t*) to substitute with
225  * @param  entry Entry to be modified 
226  * @param  lgth new value length
227  */
228 bool DocEntrySet::SetBinEntry(uint8_t *content, int lgth, BinEntry *entry)
229 {
230    if(entry)
231    {
232       entry->SetBinArea(content);  
233       entry->SetLength(lgth);
234       entry->SetValue(GDCM_BINLOADED);
235       return true;
236    }
237    return false;
238 }
239
240 /**
241  * \brief   Modifies the value of a given Doc Entry (Dicom Element)
242  *          when it exists. Create it with the given value when unexistant.
243  * @param   value (string) Value to be set
244  * @param   group   Group number of the Entry 
245  * @param   elem  Element number of the Entry
246  * @param   vr  V(alue) R(epresentation) of the Entry -if private Entry-
247  * \return  pointer to the modified/created Header Entry (NULL when creation
248  *          failed).
249  */ 
250 ValEntry *DocEntrySet::InsertValEntry(std::string const &value, 
251                                       uint16_t group, uint16_t elem,
252                                       TagName const &vr )
253 {
254    ValEntry *valEntry = 0;
255    DocEntry *currentEntry = GetDocEntry( group, elem );
256    
257    if (currentEntry)
258    {
259       valEntry = dynamic_cast<ValEntry *>(currentEntry);
260
261       // Verify the VR
262       if( valEntry )
263          if( valEntry->GetVR()!=vr )
264             valEntry = NULL;
265
266       // if currentEntry doesn't correspond to the requested valEntry
267       if( !valEntry)
268       {
269          if( !RemoveEntry(currentEntry) )
270          {
271             gdcmWarningMacro( "Removal of previous DocEntry failed.");
272
273             return NULL;
274          }
275       }
276    }
277
278    // Create a new valEntry if necessary
279    if( !valEntry )
280    {
281       valEntry = NewValEntry( group, elem, vr );
282
283       if ( !AddEntry(valEntry) )
284       {
285          gdcmWarningMacro("AddEntry failed although this is a creation.");
286
287          delete valEntry;
288          return NULL;
289       }
290    }
291
292    // Set the binEntry value
293    SetValEntry(value, valEntry); // The std::string value
294    return valEntry;
295 }
296
297 /**
298  * \brief   Modifies the value of a given Header Entry (Dicom Element)
299  *          when it exists. Create it with the given value when unexistant.
300  *          A copy of the binArea is made to be kept in the Document.
301  * @param   binArea (binary) value to be set
302  * @param   lgth length of the Bin Area we want to set
303  * @param   group   Group number of the Entry 
304  * @param   elem  Element number of the Entry
305  * @param   vr  V(alue) R(epresentation) of the Entry -if private Entry-
306  * \return  pointer to the modified/created Header Entry (NULL when creation
307  *          failed).
308  */
309 BinEntry *DocEntrySet::InsertBinEntry(uint8_t *binArea, int lgth, 
310                                       uint16_t group, uint16_t elem,
311                                       TagName const &vr )
312 {
313    BinEntry *binEntry = 0;
314    DocEntry *currentEntry = GetDocEntry( group, elem );
315
316    // Verify the currentEntry
317    if (currentEntry)
318    {
319       binEntry = dynamic_cast<BinEntry *>(currentEntry);
320
321       // Verify the VR
322       if( binEntry )
323          if( binEntry->GetVR()!=vr )
324             binEntry = NULL;
325
326       // if currentEntry doesn't correspond to the requested valEntry
327       if( !binEntry)
328       {
329          if( !RemoveEntry(currentEntry) )
330          {
331             gdcmWarningMacro( "Removal of previous DocEntry failed.");
332
333             return NULL;
334          }
335       }
336    }
337
338    // Create a new binEntry if necessary
339    if( !binEntry)
340    {
341       binEntry = NewBinEntry(group, elem, vr);
342
343       if ( !AddEntry(binEntry) )
344       {
345          gdcmWarningMacro( "AddEntry failed allthough this is a creation.");
346
347          delete binEntry;
348          return NULL;
349       }
350    }
351
352    // Set the binEntry value
353    uint8_t *tmpArea;
354    if( lgth>0 && binArea )
355    {
356       tmpArea = new uint8_t[lgth];
357       memcpy(tmpArea,binArea,lgth);
358    }
359    else
360    {
361       tmpArea = 0;
362    }
363    if( !SetBinEntry(tmpArea,lgth,binEntry) )
364    {
365       if( tmpArea )
366       {
367          delete[] tmpArea;
368       }
369    }
370
371    return binEntry;
372 }  
373
374 /**
375  * \brief   Modifies the value of a given Header Entry (Dicom Element)
376  *          when it exists. Creates it when unexistant.
377  * @param   group   Group number of the Entry 
378  * @param   elem  Element number of the Entry
379  * \return  pointer to the modified/created SeqEntry (NULL when creation
380  *          failed).
381  */
382 SeqEntry *DocEntrySet::InsertSeqEntry(uint16_t group, uint16_t elem)
383 {
384    SeqEntry *seqEntry = 0;
385    DocEntry *currentEntry = GetDocEntry( group, elem);
386
387    // Verify the currentEntry
388    if( currentEntry )
389    {
390       seqEntry = dynamic_cast<SeqEntry *>(currentEntry);
391
392       // Verify the VR
393       if( seqEntry )
394          if( seqEntry->GetVR()!="SQ" )
395             seqEntry = NULL;
396
397       // if currentEntry doesn't correspond to the requested valEntry
398       if( !seqEntry )
399       {
400          if (!RemoveEntry(currentEntry))
401          {
402             gdcmWarningMacro( "Removal of previous DocEntry failed.");
403
404             return NULL;
405          }
406       }
407    }
408    // Create a new seqEntry if necessary
409    if( !seqEntry )
410    {
411       seqEntry = NewSeqEntry(group, elem);
412
413       if( !AddEntry(seqEntry) )
414       {
415          gdcmWarningMacro( "AddEntry failed allthough this is a creation.");
416
417          delete seqEntry;
418          return NULL;
419       }
420    }
421    return seqEntry;
422
423  
424 /**
425  * \brief   Checks if a given Dicom Element exists within the H table
426  * @param   group   Group number of the searched Dicom Element 
427  * @param   elem  Element number of the searched Dicom Element 
428  * @return true is found
429  */
430 bool DocEntrySet::CheckIfEntryExist(uint16_t group, uint16_t elem )
431 {
432    return GetDocEntry(group,elem)!=NULL;
433 }
434
435 /**
436  * \brief   Build a new Val Entry from all the low level arguments. 
437  *          Check for existence of dictionary entry, and build
438  *          a default one when absent.
439  * @param   group group   number of the new Entry
440  * @param   elem  element number of the new Entry
441  * @param   vr     VR of the new Entry 
442  */
443 ValEntry *DocEntrySet::NewValEntry(uint16_t group,uint16_t elem,
444                                    TagName const &vr) 
445 {
446    DictEntry *dictEntry = GetDictEntry(group, elem, vr);
447    gdcmAssertMacro(dictEntry);
448
449    ValEntry *newEntry = new ValEntry(dictEntry);
450    if (!newEntry) 
451    {
452       gdcmWarningMacro( "Failed to allocate ValEntry");
453       return 0;
454    }
455    return newEntry;
456 }
457
458
459 /**
460  * \brief   Build a new Bin Entry from all the low level arguments. 
461  *          Check for existence of dictionary entry, and build
462  *          a default one when absent.
463  * @param   group group   number of the new Entry
464  * @param   elem  element number of the new Entry
465  * @param   vr     VR of the new Entry 
466  */
467 BinEntry *DocEntrySet::NewBinEntry(uint16_t group, uint16_t elem,
468                                    TagName const &vr) 
469 {
470    DictEntry *dictEntry = GetDictEntry(group, elem, vr);
471    gdcmAssertMacro(dictEntry);
472
473    BinEntry *newEntry = new BinEntry(dictEntry);
474    if (!newEntry) 
475    {
476       gdcmWarningMacro( "Failed to allocate BinEntry");
477       return 0;
478    }
479    return newEntry;
480 }
481
482 /**
483  * \brief   Build a new Seq Entry from all the low level arguments. 
484  *          Check for existence of dictionary entry, and build
485  *          a default one when absent.
486  * @param   group group   number of the new Entry
487  * @param   elem  element number of the new Entry
488  */
489 SeqEntry* DocEntrySet::NewSeqEntry(uint16_t group, uint16_t elem) 
490 {
491    DictEntry *dictEntry = GetDictEntry(group, elem, "SQ");
492    gdcmAssertMacro(dictEntry);
493
494    SeqEntry *newEntry = new SeqEntry( dictEntry );
495    if (!newEntry)
496    {
497       gdcmWarningMacro( "Failed to allocate SeqEntry");
498       return 0;
499    }
500    return newEntry;
501 }
502
503 /**
504  * \brief   Request a new virtual dict entry to the dict set
505  * @param   group group  number of the underlying DictEntry
506  * @param   elem  element number of the underlying DictEntry
507  * @param   vr    VR (Value Representation) of the underlying DictEntry
508  * @param   vm    VM (Value Multiplicity)   of the underlying DictEntry
509  * @param   name   english name
510  */
511 DictEntry* DocEntrySet::NewVirtualDictEntry( uint16_t group, uint16_t elem,
512                                              TagName const &vr,
513                                              TagName const &vm,
514                                              TagName const &name )
515 {
516    return Global::GetDicts()->NewVirtualDictEntry(group,elem,vr,vm,name);
517 }
518
519 //-----------------------------------------------------------------------------
520 // Protected
521 /**
522  * \brief   Searches [both] the public [and the shadow dictionary (when they
523  *          exist)] for the presence of the DictEntry with given
524  *          group and element. The public dictionary has precedence on the
525  *          shadow one.
526  * @param   group  group number of the searched DictEntry
527  * @param   elem element number of the searched DictEntry
528  * @return  Corresponding DictEntry when it exists, NULL otherwise.
529  */
530 DictEntry *DocEntrySet::GetDictEntry(uint16_t group,uint16_t elem) 
531 {
532    DictEntry *found = 0;
533    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
534    if (!pubDict) 
535    {
536       gdcmWarningMacro( "We SHOULD have a default dictionary");
537    }
538    else
539    {
540       found = pubDict->GetEntry(group, elem);  
541    }
542    return found;
543 }
544
545 /**
546  * \brief   Searches [both] the public [and the shadow dictionary (when they
547  *          exist)] for the presence of the DictEntry with given
548  *          group and element, and create a new virtual DictEntry if necessary
549  * @param   group  group number of the searched DictEntry
550  * @param   elem element number of the searched DictEntry
551  * @param   vr Value Representation to use, if necessary 
552  * @return  Corresponding DictEntry when it exists, NULL otherwise.
553  */
554 DictEntry *DocEntrySet::GetDictEntry(uint16_t group, uint16_t elem,
555                                      TagName const &vr)
556 {
557    DictEntry *dictEntry = GetDictEntry(group,elem);
558    DictEntry *goodEntry = dictEntry;
559    std::string goodVR = vr;
560
561    if (elem == 0x0000) goodVR="UL";
562
563    if ( goodEntry )
564    {
565       if ( goodVR != goodEntry->GetVR()
566         && goodVR != GDCM_UNKNOWN )
567       {
568          goodEntry = NULL;
569       }
570    }
571
572    // Create a new virtual DictEntry if necessary
573    if (!goodEntry)
574    {
575       if (dictEntry)
576       {
577          goodEntry = NewVirtualDictEntry(group, elem, goodVR, "FIXME", 
578                                          dictEntry->GetName() );
579       }
580       else
581       {
582          goodEntry = NewVirtualDictEntry(group, elem, goodVR);
583       }
584    }
585    return goodEntry;
586 }
587
588 //-----------------------------------------------------------------------------
589 // Private
590
591 //-----------------------------------------------------------------------------
592 // Print
593
594 //-----------------------------------------------------------------------------
595 } // end namespace gdcm