]> Creatis software - gdcm.git/blob - gdcmDataEntry.cxx
f80dd7d290db83810222a52b1334f7b470b2e6af
[gdcm.git] / gdcmDataEntry.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmDataEntry.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/11/21 12:15:06 $
7   Version:   $Revision: 1.23 $
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 "gdcmDataEntry.h"
20 #include "gdcmVR.h"
21 #include "gdcmTS.h"
22 #include "gdcmGlobal.h"
23 #include "gdcmUtil.h"
24 #include "gdcmDebug.h"
25
26 #include <fstream>
27
28 namespace gdcm 
29 {
30 //-----------------------------------------------------------------------------
31 #define MAX_SIZE_PRINT_ELEMENT_VALUE 0x7fffffff
32 uint32_t DataEntry::MaxSizePrintEntry = MAX_SIZE_PRINT_ELEMENT_VALUE;
33
34 //-----------------------------------------------------------------------------
35 // Constructor / Destructor
36 /**
37  * \brief   Constructor for a given DictEntry
38  * @param   e Pointer to existing dictionary entry
39  */
40 DataEntry::DataEntry(DictEntry *e) 
41             : DocEntry(e)
42 {
43    State = STATE_LOADED;
44    Flag = FLAG_NONE;
45
46    BinArea = 0;
47    SelfArea = true;
48 }
49
50 /**
51  * \brief   Constructor for a given DocEntry
52  * @param   e Pointer to existing Doc entry
53  */
54 DataEntry::DataEntry(DocEntry *e)
55             : DocEntry(e->GetDictEntry())
56 {
57    Flag = FLAG_NONE;
58    BinArea = 0;
59    SelfArea = true;
60
61    Copy(e);
62 }
63
64 /**
65  * \brief   Canonical destructor.
66  */
67 DataEntry::~DataEntry ()
68 {
69    DeleteBinArea();
70 }
71
72 //-----------------------------------------------------------------------------
73 // Print
74
75 //-----------------------------------------------------------------------------
76 // Public
77 /**
78  * \brief Sets the value (non string) of the current Dicom Header Entry
79  */
80 void DataEntry::SetBinArea( uint8_t *area, bool self )  
81
82    DeleteBinArea();
83
84    BinArea = area;
85    SelfArea = self;
86
87    State = STATE_LOADED;
88 }
89 /**
90  * \brief Inserts the value (non string) into the current Dicom Header Entry
91  */
92 void DataEntry::CopyBinArea( uint8_t *area, uint32_t length )
93 {
94    DeleteBinArea();
95
96    uint32_t lgh = length + length%2;
97    SetLength(lgh);
98
99    if( area && length > 0 )
100    {
101       NewBinArea();
102       memcpy(BinArea,area,length);
103       if( length!=lgh )
104          BinArea[length]=0;
105
106       State = STATE_LOADED;
107    }
108 }
109
110 void DataEntry::SetValue(const uint32_t &id, const double &val)
111 {
112    if( !BinArea )
113       NewBinArea();
114    State = STATE_LOADED;
115
116    if( id > GetValueCount() )
117    {
118       gdcmErrorMacro("Index (" << id << ")is greater than the data size");
119       return;
120    }
121
122    const VRKey &vr = GetVR();
123    if( vr == "US" || vr == "SS" )
124    {
125       uint16_t *data = (uint16_t *)BinArea;
126       data[id] = (uint16_t)val;
127    }
128    else if( vr == "UL" || vr == "SL" )
129    {
130       uint32_t *data = (uint32_t *)BinArea;
131       data[id] = (uint32_t)val;
132    }
133    else if( vr == "FL" )
134    {
135       float *data = (float *)BinArea;
136       data[id] = (float)val;
137    }
138    else if( vr == "FD" )
139    {
140       double *data = (double *)BinArea;
141       data[id] = (double)val;
142    }
143    else if( Global::GetVR()->IsVROfStringRepresentable(vr) )
144    {
145       gdcmErrorMacro("SetValue on String representable not implemented yet");
146    }
147    else
148    {
149       BinArea[id] = (uint8_t)val;
150    }
151 }
152 /**
153  * \brief returns, as a double (?!?) one of the values 
154  //      (when entry is multivaluated), identified by its index.
155  //      Returns 0.0 if index is wrong
156  //     FIXME : warn the user there was a problem ! 
157  */
158 double DataEntry::GetValue(const uint32_t &id) const
159 {
160    if( !BinArea )
161    {
162       gdcmErrorMacro("BinArea not set. Can't get the value");
163       return 0.0;
164    }
165
166    uint32_t count = GetValueCount();
167    if( id > count )
168    {
169       gdcmErrorMacro("Index (" << id << ")is greater than the data size");
170       return 0.0;
171    }
172
173    // FIX the API : user *knows* that entry contains a US
174    //               and he receives a double ?!?
175    
176    const VRKey &vr = GetVR();
177    if( vr == "US" || vr == "SS" )
178       return ((uint16_t *)BinArea)[id];
179    else if( vr == "UL" || vr == "SL" )
180       return ((uint32_t *)BinArea)[id];
181    else if( vr == "FL" )
182       return ((float *)BinArea)[id];
183    else if( vr == "FD" )
184       return ((double *)BinArea)[id];
185    else if( Global::GetVR()->IsVROfStringRepresentable(vr) )
186    {
187       if( GetLength() )
188       {
189          // Don't use std::string to accelerate processing
190          double val;
191          char *tmp = new char[GetLength()+1];
192          memcpy(tmp,BinArea,GetLength());
193          tmp[GetLength()]=0;
194
195          if( count == 0 )
196          {
197             val = atof(tmp);
198          }
199          else
200          {
201             count = id;
202             char *beg = tmp;
203             for(uint32_t i=0;i<GetLength();i++)
204             {
205                if( tmp[i] == '\\' )
206                {
207                   if( count == 0 )
208                   {
209                      tmp[i] = 0;
210                      break;
211                   }
212                   else
213                   {
214                      count--;
215                      beg = &(tmp[i+1]);
216                   }
217                }
218             }
219             val = atof(beg);
220          }
221
222          delete[] tmp;
223          return val;
224       }
225       else 
226          return 0.0;
227    }
228    else
229       return BinArea[id];
230 }
231
232 /**
233  * \brief Checks if the multiplicity of the value follows Dictionary VM
234  */
235 bool DataEntry::IsValueCountValid() const
236 {
237   uint32_t vm;
238   const std::string &strVM = GetVM();
239   uint32_t vc = GetValueCount();
240   bool valid = vc == 0;
241   if( valid )
242     return true;
243   
244   // FIXME : what shall we do with VM = "2-n", "3-n", etc
245   
246   if( strVM == "1-n" )
247   {
248     // make sure there is at least one ??? FIXME
249     valid = vc >= 1;
250   }
251   else
252   {
253     std::istringstream os;
254     os.str( strVM );
255     os >> vm;
256     // Two cases:
257     // vm respects the one from the dict
258     // vm is 0 (we need to check if this element is allowed to be empty) FIXME
259
260     // note  (JPR)
261     // ----    
262     // Entries whose type is 1 are mandatory, with a mandatory value.
263     // Entries whose type is 1c are mandatory-inside-a-Sequence,
264     //                          with a mandatory value.
265     // Entries whose type is 2 are mandatory, with an optional value.
266     // Entries whose type is 2c are mandatory-inside-a-Sequence,
267     //                          with an optional value.
268     // Entries whose type is 3 are optional.
269
270     // case vc == 0 is only applicable for 'type 2' entries.
271     // Problem : entry type may depend on the modality and/or the Sequence
272     //           it's embedded in !
273     //          (Get the information in the 'Conformance Statements' ...)  
274     valid = vc == vm;
275   }
276   return valid;
277 }
278
279 /**
280  * \brief returns the number of elementary values
281  */ 
282 uint32_t DataEntry::GetValueCount( ) const
283 {
284    const VRKey &vr = GetVR();
285    if( vr == "US" || vr == "SS" )
286       return GetLength()/sizeof(uint16_t);
287    else if( vr == "UL" || vr == "SL" )
288       return GetLength()/sizeof(uint32_t);
289    else if( vr == "FL" || vr == "OF" )
290       return GetLength()/4 ; // FL has a *4* length! sizeof(float);
291    else if( vr == "FD" )
292       return GetLength()/8;  // FD has a *8* length! sizeof(double);
293    else if( Global::GetVR()->IsVROfStringRepresentable(vr) )
294    {
295       // Some element in DICOM are allowed to be empty
296       if( !GetLength() ) 
297          return 0;
298       // Don't use std::string to accelerate processing
299       uint32_t count = 1;
300       for(uint32_t i=0;i<GetLength();i++)
301       {
302          if( BinArea[i] == '\\')
303             count++;
304       }
305       return count;
306    }
307    return GetLength();
308 }
309 /**
310  * \brief Sets the 'value' of an Entry, passed as a std::string
311  * @param value string representation of the value to be set
312  */ 
313 void DataEntry::SetString(std::string const &value)
314 {
315    DeleteBinArea();
316
317    const VRKey &vr = GetVR();
318    if ( vr == "US" || vr == "SS" )
319    {
320       std::vector<std::string> tokens;
321       Util::Tokenize (value, tokens, "\\");
322       SetLength(tokens.size()*sizeof(uint16_t));
323       NewBinArea();
324
325       uint16_t *data = (uint16_t *)BinArea;
326       for (unsigned int i=0; i<tokens.size();i++)
327          data[i] = atoi(tokens[i].c_str());
328       tokens.clear();
329    }
330    else if ( vr == "UL" || vr == "SL" )
331    {
332       std::vector<std::string> tokens;
333       Util::Tokenize (value, tokens, "\\");
334       SetLength(tokens.size()*sizeof(uint32_t));
335       NewBinArea();
336
337       uint32_t *data = (uint32_t *)BinArea;
338       for (unsigned int i=0; i<tokens.size();i++)
339          data[i] = atoi(tokens[i].c_str());
340       tokens.clear();
341    }
342    else if ( vr == "FL" )
343    {
344       std::vector<std::string> tokens;
345       Util::Tokenize (value, tokens, "\\");
346       SetLength(tokens.size()*sizeof(float));
347       NewBinArea();
348
349       float *data = (float *)BinArea;
350       for (unsigned int i=0; i<tokens.size();i++)
351          data[i] = (float)atof(tokens[i].c_str());
352       tokens.clear();
353    }
354    else if ( vr == "FD" )
355    {
356       std::vector<std::string> tokens;
357       Util::Tokenize (value, tokens, "\\");
358       SetLength(tokens.size()*sizeof(double));
359       NewBinArea();
360
361       double *data = (double *)BinArea;
362       for (unsigned int i=0; i<tokens.size();i++)
363          data[i] = atof(tokens[i].c_str());
364       tokens.clear();
365    }
366    else
367    {
368       if( value.size() > 0 )
369       {
370          size_t l =  value.size();    
371          SetLength(l + l%2);
372          NewBinArea();
373          memcpy(BinArea, value.c_str(), l);
374          if (l%2)
375             BinArea[l] = '\0';
376       }
377    }
378    State = STATE_LOADED;
379 }
380 /**
381  * \brief   returns as a string (when possible) the value of the DataEntry
382  */
383 std::string const &DataEntry::GetString() const
384 {
385    static std::ostringstream s;
386    const VRKey &vr = GetVR();
387
388    s.str("");
389    StrArea="";
390
391    if( !BinArea )
392       return StrArea;
393       
394    // When short integer(s) are stored, convert the following (n * 2) characters 
395    // as a displayable string, the values being separated by a back-slash
396
397    if( vr == "US" || vr == "SS" )
398    {
399       uint16_t *data=(uint16_t *)BinArea;
400
401       for (unsigned int i=0; i < GetValueCount(); i++)
402       {
403          if( i!=0 )
404             s << '\\';
405          s << data[i];
406       }
407       StrArea=s.str();
408    }
409    // See above comment on multiple short integers (mutatis mutandis).
410    else if( vr == "UL" || vr == "SL" )
411    {
412       uint32_t *data=(uint32_t *)BinArea;
413
414       for (unsigned int i=0; i < GetValueCount(); i++)
415       {
416          if( i!=0 )
417             s << '\\';
418          s << data[i];
419       }
420       StrArea=s.str();
421    }
422    else if( vr == "FL" )
423    {
424       float *data=(float *)BinArea;
425
426       for (unsigned int i=0; i < GetValueCount(); i++)
427       {
428          if( i!=0 )
429             s << '\\';
430          s << data[i];
431       }
432       StrArea=s.str();
433    }
434    else if( vr == "FD" )
435    {
436       double *data=(double *)BinArea;
437
438       for (unsigned int i=0; i < GetValueCount(); i++)
439       {
440          if( i!=0 )
441             s << '\\';
442          s << data[i];
443       }
444       StrArea=s.str();
445    }
446    else
447    {
448       StrArea.append((const char *)BinArea,GetLength());
449       // to avoid gdcm propagate oddities in lengthes
450       if ( GetLength()%2)
451          StrArea.append(" ",1);  
452    }
453    return StrArea;
454 }
455 /**
456  * \brief   Copies all the attributes from an other DocEntry 
457  * @param doc entry to copy from
458  */
459 void DataEntry::Copy(DocEntry *doc)
460 {
461    DocEntry::Copy(doc);
462
463    DataEntry *entry = dynamic_cast<DataEntry *>(doc);
464    if ( entry )
465    {
466       State = entry->State;
467       Flag = entry->Flag;
468       CopyBinArea(entry->BinArea,entry->GetLength());
469    }
470 }
471 /**
472  * \brief   Writes the 'value' area of a DataEntry
473  * @param fp already open ofstream pointer
474  * @param filetype type of the file (ACR, ImplicitVR, ExplicitVR, ...)
475  */
476 void DataEntry::WriteContent(std::ofstream *fp, FileType filetype)
477
478    DocEntry::WriteContent(fp, filetype);
479
480    if ( GetGroup() == 0xfffe )
481    {
482       return; //delimitors have NO value
483    }
484    
485    // --> We only deal with Little Endian writting
486    // --> forget Big Endian Transfer Syntax writting!
487    //     Next DICOM version will give it up ...
488  
489    // WARNING - For Implicit VR private element,
490    //           we have *no choice* but considering them as
491    //           something like 'OB' values.
492    //           we rewrite them as we found them on disc.
493    //           Some trouble will occur if element was 
494    //           *actually* OW, if image was produced 
495    //           on Big endian based processor, read and writen 
496    //           on Little endian based processor
497    //           and, later on, somebody needs
498    //           this 'OW' Implicit VR private element (?!?)
499    //           (Same stuff, mutatis mutandis, for Little/Big)
500  
501    // 8/16 bits Pixels problem should be solved automatiquely,
502    // since we ensure the VR (OB vs OW) is conform to Pixel size.
503         
504    uint8_t *data = BinArea; //safe notation
505    size_t l = GetLength(); 
506    gdcmDebugMacro ("in DataEntry::WriteContent " << GetKey() 
507              << " : " << Global::GetVR()->GetAtomicElementLength(this->GetVR())
508              );
509    if (BinArea) // the binArea was *actually* loaded
510    {
511 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
512       unsigned short vrLgth = 
513                         Global::GetVR()->GetAtomicElementLength(this->GetVR());
514       unsigned int i;
515       switch(vrLgth)
516       {
517          case 1:
518          {
519             binary_write (*fp, data, l );           
520             break;
521          }     
522          case 2:
523          {
524 gdcmDebugMacro ("AtomicLength = 2 found; lgt =" << l); 
525             uint16_t *data16 = (uint16_t *)data;
526             for(i=0;i<l/vrLgth;i++)
527                binary_write( *fp, data16[i]);
528             break;
529          }
530          case 4:
531          {
532             uint32_t *data32 = (uint32_t *)data;
533             for(i=0;i<l/vrLgth;i++)
534                binary_write( *fp, data32[i]);
535             break;
536          }
537          case 8:
538          {
539             double *data64 = (double *)data;
540             for(i=0;i<l/vrLgth;i++)
541                binary_write( *fp, data64[i]);
542             break;
543          }
544       }
545 #else
546    binary_write (*fp, data, l );
547 #endif //GDCM_WORDS_BIGENDIAN
548
549    }
550    else
551    {
552       // nothing was loaded, but we need to skip space on disc
553       
554       //  --> WARNING : nothing is written; 
555       //  --> the initial data (on the the source image) is lost
556       //  --> user is *not* informed !
557       
558       fp->seekp(l, std::ios::cur);
559    }
560    // to avoid gdcm to propagate oddities
561    // (length was already modified)  
562    if (l%2)
563       fp->seekp(1, std::ios::cur);  
564 }
565
566 /**
567  * \brief   Compute the full length of the elementary DataEntry (not only value
568  *          length) depending on the VR.
569  */
570 uint32_t DataEntry::ComputeFullLength()
571 {
572    return GetFullLength();
573 }
574
575 //-----------------------------------------------------------------------------
576 // Protected
577 /// \brief Creates a DataEntry owned BinArea (remove previous one if any)
578 void DataEntry::NewBinArea(void)
579 {
580    DeleteBinArea();
581    if( GetLength() > 0 )
582       BinArea = new uint8_t[GetLength()];
583    SelfArea = true;
584 }
585 /// \brief Removes the BinArea, if owned by the DataEntry
586 void DataEntry::DeleteBinArea(void)
587 {
588    if (BinArea && SelfArea)
589    {
590       delete[] BinArea;
591       BinArea = NULL;
592    }
593 }
594
595 //-----------------------------------------------------------------------------
596 // Private
597
598 //-----------------------------------------------------------------------------
599 // Print
600 /**
601  * \brief   Prints a DataEntry (Dicom entry)
602  * @param   os ostream we want to print in
603  * @param indent Indentation string to be prepended during printing
604  */
605 void DataEntry::Print(std::ostream &os, std::string const & )
606 {
607    os << "D ";
608    DocEntry::Print(os);
609
610    uint16_t g = GetGroup();
611    if (g == 0xfffe) // delimiters have NO value
612    {          
613       return; // just to avoid identing all the remaining code 
614    }
615
616    std::ostringstream s;
617    TSAtr v;
618
619    if( BinArea )
620    {
621       v = GetString();
622       const VRKey &vr = GetVR();
623
624       if( vr == "US" || vr == "SS" )
625          s << " [" << GetString() << "]";
626       else if( vr == "UL" || vr == "SL" )
627          s << " [" << GetString() << "]";
628       else if ( vr == "FL" )
629          s << " [" << GetString() << "]";
630       else if ( vr == "FD" )
631          s << " [" << GetString() << "]";
632       else
633       { 
634          if(Global::GetVR()->IsVROfStringRepresentable(vr))
635          {
636             // replace non printable characters by '.'
637             std::string cleanString = Util::CreateCleanString(v);
638             if ( cleanString.length() <= GetMaxSizePrintEntry()
639               || PrintLevel >= 3
640               || IsNotLoaded() )
641            // FIXME : when IsNotLoaded(), you create a Clean String ?!?
642            // FIXME : PrintLevel<2 *does* print the values 
643            //        (3 is only for extra offsets printing)
644            // What do you wanted to do ? JPR
645             {
646                s << " [" << cleanString << "]";
647             }
648             else
649             {
650                s << " [gdcm::too long for print (" << cleanString.length() << ") ]";
651             }
652          }
653          else
654          {
655             // A lot of Private elements (with no VR) contain actually 
656             // only printable characters;
657             // Let's deal with them as is they were VR std::string representable
658     
659             if ( Util::IsCleanArea( GetBinArea(), GetLength()  ) )
660             {
661                // FIXME : since the 'Area' *is* clean, just use
662                //         a 'CreateString' method, to save CPU time.
663                std::string cleanString = 
664                      Util::CreateCleanString( BinArea,GetLength()  );
665                s << " [" << cleanString << "]";
666             }
667             else
668             {
669                s << " [" << GDCM_BINLOADED << ";"
670                << "length = " << GetLength() << "]";
671             }
672          }
673       }
674    }
675    else
676    {
677       if( IsNotLoaded() )
678          s << " [" << GDCM_NOTLOADED << "]";
679       else if( IsUnfound() )
680          s << " [" << GDCM_UNFOUND << "]";
681       else if( IsUnread() )
682          s << " [" << GDCM_UNREAD << "]";
683       else if ( GetLength() == 0 )
684          s << " []";
685    }
686
687    if( IsPixelData() )
688       s << " (" << GDCM_PIXELDATA << ")";
689
690    // Display the UID value (instead of displaying only the rough code)
691    // First 'clean' trailing character (space or zero) 
692    if(BinArea)
693    {
694       const uint16_t &gr = GetGroup();
695       const uint16_t &elt = GetElement();
696       TS *ts = Global::GetTS();
697
698       if (gr == 0x0002)
699       {
700          // Any more to be displayed ?
701          if ( elt == 0x0010 || elt == 0x0002 )
702          {
703             if ( v.length() != 0 )  // for brain damaged headers
704             {
705                if ( ! isdigit((unsigned char)v[v.length()-1]) )
706                {
707                   v.erase(v.length()-1, 1);
708                }
709             }
710             s << "  ==>\t[" << ts->GetValue(v) << "]";
711          }
712       }
713       else if (gr == 0x0008)
714       {
715          if ( elt == 0x0016 || elt == 0x1150 )
716          {
717             if ( v.length() != 0 )  // for brain damaged headers
718             {
719                if ( ! isdigit((unsigned char)v[v.length()-1]) )
720                {
721                   v.erase(v.length()-1, 1);
722                }
723             }
724             s << "  ==>\t[" << ts->GetValue(v) << "]";
725          }
726       }
727       else if (gr == 0x0004)
728       {
729          if ( elt == 0x1510 || elt == 0x1512  )
730          {
731             if ( v.length() != 0 )  // for brain damaged headers  
732             {
733                if ( ! isdigit((unsigned char)v[v.length()-1]) )
734                {
735                   v.erase(v.length()-1, 1);  
736                }
737             }
738             s << "  ==>\t[" << ts->GetValue(v) << "]";
739          }
740       }
741    }
742
743    os << s.str();
744 }
745
746 //-----------------------------------------------------------------------------
747 } // end namespace gdcm
748