src/gdcmDataEntry.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmDataEntry.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/10/26 15:48:33 $
   7   Version:   $Revision: 1.12 $
   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 = 0;
  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   bool valid;
 238   uint32_t vm;
 239   const std::string &strVM = GetVM();
 240   uint32_t vc = GetValueCount();
 241
 242   // FIXME : what shall we do with VM = "2-n", "3-n", etc
 243
 244   if( strVM == "1-n" )
 245   {
 246     // make sure it is at least one ??? FIXME
 247     valid = vc >= 1 || vc == 0;
 248   }
 249   else
 250   {
 251     std::istringstream os;
 252     os.str( strVM );
 253     os >> vm;
 254     // Two cases:
 255     // vm respect the one from the dict
 256     // vm is 0 (we need to check if this element is allowed to be empty) FIXME
 257
 258     // note  (JPR)
 259     // ----
 260     // Entries whose type is 1 are mandatory, with a mandatory value.
 261     // Entries whose type is 1c are mandatory-inside-a-Sequence,
 262     //                          with a mandatory value.
 263     // Entries whose type is 2 are mandatory, with an optional value.
 264     // Entries whose type is 2c are mandatory-inside-a-Sequence,
 265     //                          with an optional value.
 266     // Entries whose type is 3 are optional.
 267
 268     // case vc == 0 is only applicable for 'type 2' entries.
 269     // Problem : entry type may depend on the modality and/or the Sequence
 270     //           it's embedded in !
 271     //          (Get the information in the 'Conformance Statements' ...)
 272     valid = vc == vm || vc == 0;
 273   }
 274   return valid;
 275 }
 276
 277 /**
 278  * \brief returns the number of elementary values
 279  */
 280 uint32_t DataEntry::GetValueCount( ) const
 281 {
 282    const VRKey &vr = GetVR();
 283    if( vr == "US" || vr == "SS" )
 284       return GetLength()/sizeof(uint16_t);
 285    else if( vr == "UL" || vr == "SL" )
 286       return GetLength()/sizeof(uint32_t);
 287    else if( vr == "FL" )
 288       return GetLength()/sizeof(float);
 289    else if( vr == "FD" )
 290       return GetLength()/sizeof(double);
 291    else if( Global::GetVR()->IsVROfStringRepresentable(vr) )
 292    {
 293       // Some element in DICOM are allowed to be empty
 294       if( !GetLength() ) return 0;
 295       // Don't use std::string to accelerate processing
 296       uint32_t count = 1;
 297       for(uint32_t i=0;i<GetLength();i++)
 298       {
 299          if( BinArea[i] == '\\')
 300             count++;
 301       }
 302       return count;
 303    }
 304
 305    return GetLength();
 306 }
 307 /**
 308  * \brief Sets the 'value' of an Entry, passed as a std::string
 309  * @param value string representation of the value to be set
 310  */
 311 void DataEntry::SetString(std::string const &value)
 312 {
 313    DeleteBinArea();
 314
 315    const VRKey &vr = GetVR();
 316    if ( vr == "US" || vr == "SS" )
 317    {
 318       std::vector<std::string> tokens;
 319       Util::Tokenize (value, tokens, "\\");
 320       SetLength(tokens.size()*sizeof(uint16_t));
 321       NewBinArea();
 322
 323       uint16_t *data = (uint16_t *)BinArea;
 324       for (unsigned int i=0; i<tokens.size();i++)
 325          data[i] = atoi(tokens[i].c_str());
 326       tokens.clear();
 327    }
 328    else if ( vr == "UL" || vr == "SL" )
 329    {
 330       std::vector<std::string> tokens;
 331       Util::Tokenize (value, tokens, "\\");
 332       SetLength(tokens.size()*sizeof(uint32_t));
 333       NewBinArea();
 334
 335       uint32_t *data = (uint32_t *)BinArea;
 336       for (unsigned int i=0; i<tokens.size();i++)
 337          data[i] = atoi(tokens[i].c_str());
 338       tokens.clear();
 339    }
 340    else if ( vr == "FL" )
 341    {
 342       std::vector<std::string> tokens;
 343       Util::Tokenize (value, tokens, "\\");
 344       SetLength(tokens.size()*sizeof(float));
 345       NewBinArea();
 346
 347       float *data = (float *)BinArea;
 348       for (unsigned int i=0; i<tokens.size();i++)
 349          data[i] = (float)atof(tokens[i].c_str());
 350       tokens.clear();
 351    }
 352    else if ( vr == "FD" )
 353    {
 354       std::vector<std::string> tokens;
 355       Util::Tokenize (value, tokens, "\\");
 356       SetLength(tokens.size()*sizeof(double));
 357       NewBinArea();
 358
 359       double *data = (double *)BinArea;
 360       for (unsigned int i=0; i<tokens.size();i++)
 361          data[i] = atof(tokens[i].c_str());
 362       tokens.clear();
 363    }
 364    else
 365    {
 366       if( value.size() > 0 )
 367       {
 368          // FIXME : should be quicker if we don't create one more std::string
 369          //         just to make even the length of a char array ...
 370
 371          /*
 372          std::string finalVal = Util::DicomString( value.c_str() );
 373          SetLength(finalVal.size());
 374          NewBinArea();
 375
 376          memcpy(BinArea, &(finalVal[0]), finalVal.size());
 377          */
 378
 379          size_t l =  value.size();
 380          SetLength(l + l%2);
 381          NewBinArea();
 382          //memcpy(BinArea, &(value[0]), l);
 383          memcpy(BinArea, value.c_str(), l);
 384          if (l%2)
 385             BinArea[l] = '\0';
 386       }
 387    }
 388    State = STATE_LOADED;
 389 }
 390 /**
 391  * \brief   returns as a string (when possible) the value of the DataEntry
 392  */
 393 std::string const &DataEntry::GetString() const
 394 {
 395    static std::ostringstream s;
 396    const VRKey &vr = GetVR();
 397
 398    s.str("");
 399    StrArea="";
 400
 401    if( !BinArea )
 402       return StrArea;
 403
 404    // When short integer(s) are stored, convert the following (n * 2) characters
 405    // as a displayable string, the values being separated by a back-slash
 406
 407    if( vr == "US" || vr == "SS" )
 408    {
 409       uint16_t *data=(uint16_t *)BinArea;
 410
 411       for (unsigned int i=0; i < GetValueCount(); i++)
 412       {
 413          if( i!=0 )
 414             s << '\\';
 415          s << data[i];
 416       }
 417       StrArea=s.str();
 418    }
 419    // See above comment on multiple short integers (mutatis mutandis).
 420    else if( vr == "UL" || vr == "SL" )
 421    {
 422       uint32_t *data=(uint32_t *)BinArea;
 423
 424       for (unsigned int i=0; i < GetValueCount(); i++)
 425       {
 426          if( i!=0 )
 427             s << '\\';
 428          s << data[i];
 429       }
 430       StrArea=s.str();
 431    }
 432    else if( vr == "FL" )
 433    {
 434       float *data=(float *)BinArea;
 435
 436       for (unsigned int i=0; i < GetValueCount(); i++)
 437       {
 438          if( i!=0 )
 439             s << '\\';
 440          s << data[i];
 441       }
 442       StrArea=s.str();
 443    }
 444    else if( vr == "FD" )
 445    {
 446       double *data=(double *)BinArea;
 447
 448       for (unsigned int i=0; i < GetValueCount(); i++)
 449       {
 450          if( i!=0 )
 451             s << '\\';
 452          s << data[i];
 453       }
 454       StrArea=s.str();
 455    }
 456    else
 457       StrArea.append((const char *)BinArea,GetLength());
 458
 459    return StrArea;
 460 }
 461 /**
 462  * \brief   Copies all the attributes from an other DocEntry
 463  * @param doc entry to copy from
 464  */
 465 void DataEntry::Copy(DocEntry *doc)
 466 {
 467    DocEntry::Copy(doc);
 468
 469    DataEntry *entry = dynamic_cast<DataEntry *>(doc);
 470    if ( entry )
 471    {
 472       State = entry->State;
 473       Flag = entry->Flag;
 474       CopyBinArea(entry->BinArea,entry->GetLength());
 475    }
 476 }
 477 /**
 478  * \brief   Writes the value of a DataEntry
 479  * @param fp already open ofstream pointer
 480  * @param filetype type of the file (ACR, ImplicitVR, ExplicitVR, ...)
 481  */
 482 void DataEntry::WriteContent(std::ofstream *fp, FileType filetype)
 483 {
 484    DocEntry::WriteContent(fp, filetype);
 485
 486    if ( GetGroup() == 0xfffe )
 487    {
 488       return; //delimitors have NO value
 489    }
 490
 491    uint8_t *binArea8 = BinArea; //safe notation
 492    size_t lgr = GetLength();
 493    if (BinArea) // the binArea was *actually* loaded
 494    {
 495
 496    //  The same operation should be done if we wanted
 497    //  to write image with Big Endian Transfer Syntax,
 498    //  while working on Little Endian Processor
 499    // --> forget Big Endian Transfer Syntax writting!
 500    //     Next DICOM version will give it up ...
 501
 502    // --> FIXME
 503    //    The stuff looks nice, but it's probably bugged,
 504    //    since troubles occur on big endian processors (SunSparc, Motorola)
 505    //    while reading the pixels of a
 506    //    gdcm-written Little-Endian 16 bits per pixel image
 507
 508 #if defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)
 509
 510       /// \todo FIXME : Right now, we only care of Pixels element
 511       ///       we should deal with *all* the BinEntries
 512       ///       Well, not really since we are not interpreting values read...
 513
 514       // 8 Bits Pixels *are* OB, 16 Bits Pixels *are* OW
 515       // -value forced while Reading process-
 516
 517       // -->  WARNING
 518       // -->        the following lines *looked* very clever,
 519       // -->        but they don't work on big endian processors.
 520       // -->        since I've no access for the moment to a big endian proc :-(
 521       // -->        I comment them out, to see the result on the dash board
 522       // -->
 523
 524       // --> Revert to initial code : TestWriteSimple hangs on Darwin :-(
 525       if (GetGroup() == 0x7fe0 && GetVR() == "OW")
 526       {
 527          uint16_t *binArea16 = (uint16_t*)binArea8;
 528          binary_write (*fp, binArea16, lgr );
 529       }
 530       else
 531       {
 532          // For any other VR, DataEntry is re-written as-is
 533          binary_write (*fp, binArea8, lgr );
 534       }
 535
 536       // -->  WARNING
 537       // -->         remove the following line, an uncomment the previous ones,
 538       // -->         if it doesn't work better
 539       // -->
 540       /*binary_write ( *fp, binArea8, lgr ); // Elem value*/
 541
 542 #else
 543       binary_write ( *fp, binArea8, lgr ); // Elem value
 544 #endif //GDCM_WORDS_BIGENDIAN
 545    }
 546    else
 547    {
 548       // nothing was loaded, but we need to skip space on disc
 549
 550       //  --> WARNING : nothing is written;
 551       //  --> the initial data (on the the source image) is lost
 552       //  --> user is *not* informed !
 553
 554       fp->seekp(lgr, std::ios::cur);
 555    }
 556 }
 557
 558 //-----------------------------------------------------------------------------
 559 // Protected
 560 void DataEntry::NewBinArea(void)
 561 {
 562    DeleteBinArea();
 563    if( GetLength() > 0 )
 564       BinArea = new uint8_t[GetLength()];
 565    SelfArea = true;
 566 }
 567
 568 void DataEntry::DeleteBinArea(void)
 569 {
 570    if (BinArea && SelfArea)
 571    {
 572       delete[] BinArea;
 573       BinArea = NULL;
 574    }
 575 }
 576
 577 //-----------------------------------------------------------------------------
 578 // Private
 579
 580 //-----------------------------------------------------------------------------
 581 // Print
 582 /**
 583  * \brief   Prints a DataEntry (Dicom entry)
 584  * @param   os ostream we want to print in
 585  * @param indent Indentation string to be prepended during printing
 586  */
 587 void DataEntry::Print(std::ostream &os, std::string const & )
 588 {
 589    os << "D ";
 590    DocEntry::Print(os);
 591
 592    uint16_t g = GetGroup();
 593    if (g == 0xfffe) // delimiters have NO value
 594    {
 595       return; // just to avoid identing all the remaining code
 596    }
 597
 598    std::ostringstream s;
 599    TSAtr v;
 600
 601    if( BinArea )
 602    {
 603       v = GetString();
 604       const VRKey &vr = GetVR();
 605
 606       if( vr == "US" || vr == "SS" )
 607          s << " [" << GetString() << "]";
 608       else if( vr == "UL" || vr == "SL" )
 609          s << " [" << GetString() << "]";
 610       else if ( vr == "FL" )
 611          s << " [" << GetString() << "]";
 612       else if ( vr == "FD" )
 613          s << " [" << GetString() << "]";
 614       else
 615       {
 616          if(Global::GetVR()->IsVROfStringRepresentable(vr))
 617          {
 618             // replace non printable characters by '.'
 619             std::string cleanString = Util::CreateCleanString(v);
 620             if ( cleanString.length() <= GetMaxSizePrintEntry()
 621               || PrintLevel >= 3
 622               || IsNotLoaded() )
 623            // FIXME : when IsNotLoaded(), you create a Clean String ?!?
 624            // FIXME : PrintLevel<2 *does* print the values
 625            //        (3 is only for extra offsets printing)
 626            // What do you wanted to do ? JPR
 627             {
 628                s << " [" << cleanString << "]";
 629             }
 630             else
 631             {
 632                s << " [gdcm::too long for print (" << cleanString.length() << ") ]";
 633             }
 634          }
 635          else
 636          {
 637             // A lot of Private elements (with no VR) contain actually
 638             // only printable characters;
 639             // Let's deal with them as is they were VR std::string representable
 640
 641             if ( Util::IsCleanArea( GetBinArea(), GetLength()  ) )
 642             {
 643                // FIXME : since the 'Area' *is* clean, just use
 644                //         a 'CreateString' method, to save CPU time.
 645                std::string cleanString =
 646                      Util::CreateCleanString( BinArea,GetLength()  );
 647                s << " [" << cleanString << "]";
 648             }
 649             else
 650             {
 651                s << " [" << GDCM_BINLOADED << ";"
 652                << "length = " << GetLength() << "]";
 653             }
 654          }
 655       }
 656    }
 657    else
 658    {
 659       if( IsNotLoaded() )
 660          s << " [" << GDCM_NOTLOADED << "]";
 661       else if( IsUnfound() )
 662          s << " [" << GDCM_UNFOUND << "]";
 663       else if( IsUnread() )
 664          s << " [" << GDCM_UNREAD << "]";
 665       else if ( GetLength() == 0 )
 666          s << " []";
 667    }
 668
 669    if( IsPixelData() )
 670       s << " (" << GDCM_PIXELDATA << ")";
 671
 672    // Display the UID value (instead of displaying only the rough code)
 673    // First 'clean' trailing character (space or zero)
 674    if(BinArea)
 675    {
 676       const uint16_t &gr = GetGroup();
 677       const uint16_t &elt = GetElement();
 678       TS *ts = Global::GetTS();
 679
 680       if (gr == 0x0002)
 681       {
 682          // Any more to be displayed ?
 683          if ( elt == 0x0010 || elt == 0x0002 )
 684          {
 685             if ( v.length() != 0 )  // for brain damaged headers
 686             {
 687                if ( ! isdigit((unsigned char)v[v.length()-1]) )
 688                {
 689                   v.erase(v.length()-1, 1);
 690                }
 691             }
 692             s << "  ==>\t[" << ts->GetValue(v) << "]";
 693          }
 694       }
 695       else if (gr == 0x0008)
 696       {
 697          if ( elt == 0x0016 || elt == 0x1150 )
 698          {
 699             if ( v.length() != 0 )  // for brain damaged headers
 700             {
 701                if ( ! isdigit((unsigned char)v[v.length()-1]) )
 702                {
 703                   v.erase(v.length()-1, 1);
 704                }
 705             }
 706             s << "  ==>\t[" << ts->GetValue(v) << "]";
 707          }
 708       }
 709       else if (gr == 0x0004)
 710       {
 711          if ( elt == 0x1510 || elt == 0x1512  )
 712          {
 713             if ( v.length() != 0 )  // for brain damaged headers
 714             {
 715                if ( ! isdigit((unsigned char)v[v.length()-1]) )
 716                {
 717                   v.erase(v.length()-1, 1);
 718                }
 719             }
 720             s << "  ==>\t[" << ts->GetValue(v) << "]";
 721          }
 722       }
 723    }
 724
 725    os << s.str();
 726 }
 727
 728 //-----------------------------------------------------------------------------
 729 } // end namespace gdcm
 730