src/gdcmTS.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmTS.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/02/05 01:37:09 $
   7   Version:   $Revision: 1.42 $
   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 "gdcmTS.h"
  20 #include "gdcmDebug.h"
  21 #include "gdcmUtil.h"
  22 #include "gdcmDictSet.h"
  23
  24 #include <fstream>
  25 #include <string>
  26 #include <iostream>
  27
  28 // TODO
  29 // a lot of troubles expected with TS : 1.2.840.113619.5.2
  30 // Implicit VR - Big Endian
  31 // see : http://www.gemedicalsystemseurope.com/euen/it_solutions/pdf/lsqxi_rev2.pdf
  32 //
  33
  34 namespace gdcm
  35 {
  36 //-----------------------------------------------------------------------------
  37 static const char *SpecialStrings[] =  {
  38   // Implicit VR Little Endian
  39   "1.2.840.10008.1.2",
  40   // Implicit VR Big Endian DLX (G.E Private)
  41   "1.2.840.113619.5.2",
  42   // Explicit VR Little Endian
  43   "1.2.840.10008.1.2.1",
  44   // Deflated Explicit VR Little Endian
  45   "1.2.840.10008.1.2.1.99",
  46   // Explicit VR Big Endian
  47   "1.2.840.10008.1.2.2",
  48   // JPEG Baseline (Process 1)
  49   "1.2.840.10008.1.2.4.50",
  50   // JPEG Extended (Process 2 & 4)
  51   "1.2.840.10008.1.2.4.51",
  52   // JPEG Extended (Process 3 & 5)
  53   "1.2.840.10008.1.2.4.52",
  54   // JPEG Spectral Selection, Non-Hierarchical (Process 6 & 8)
  55   "1.2.840.10008.1.2.4.53",
  56   // JPEG Full Progression, Non-Hierarchical (Process 10 & 12)
  57   "1.2.840.10008.1.2.4.55",
  58   // JPEG Lossless, Non-Hierarchical (Process 14)
  59   "1.2.840.10008.1.2.4.57",
  60   // JPEG Lossless, Hierarchical, First-Order Prediction (Process 14, [Selection Value 1])
  61   "1.2.840.10008.1.2.4.70",
  62   // JPEG-LS Lossless Image Compression
  63   "1.2.840.10008.1.2.4.80",
  64   // JPEG-LS Lossy (Near-Lossless) Image Compression
  65   "1.2.840.10008.1.2.4.81",
  66   // JPEG 2000 Lossless
  67   "1.2.840.10008.1.2.4.90",
  68   // JPEG 2000
  69   "1.2.840.10008.1.2.4.91",
  70   // RLE Lossless
  71   "1.2.840.10008.1.2.5",
  72   // Unknown
  73   "Unknown Transfer Syntax"
  74 };
  75
  76 //-----------------------------------------------------------------------------
  77 void FillDefaultTSDict(TSHT &ts);
  78
  79 //-----------------------------------------------------------------------------
  80 // Constructor / Destructor
  81 TS::TS()
  82 {
  83    std::string filename = DictSet::BuildDictPath() + DICT_TS;
  84    std::ifstream from(filename.c_str());
  85    if( !from )
  86    {
  87       gdcmWarningMacro("Can't open dictionary" << filename.c_str());
  88       FillDefaultTSDict( TsMap );
  89    }
  90    else
  91    {
  92       TSKey key;
  93       TSAtr name;
  94
  95       while (!from.eof())
  96       {
  97          from >> key;
  98          from >> std::ws;
  99          std::getline(from, name);
 100
 101          if(key != "")
 102          {
 103             TsMap[key] = name;
 104          }
 105       }
 106       from.close();
 107    }
 108 }
 109
 110 TS::~TS()
 111 {
 112    TsMap.clear();
 113 }
 114
 115 //-----------------------------------------------------------------------------
 116 // Public
 117 int TS::Count(TSKey const &key)
 118 {
 119    return TsMap.count(key);
 120 }
 121
 122 TSAtr const &TS::GetValue(TSKey const &key)
 123 {
 124    // First thing clean up the string sometime the transfer syntax is padded with spaces
 125    std::string copy = key;
 126    while ( copy.size() && !isdigit((unsigned char)copy[copy.size()-1]) )
 127    {
 128       copy.erase(copy.size()-1, 1);
 129    }
 130
 131    TSHT::const_iterator it = TsMap.find(copy);
 132    if (it == TsMap.end())
 133    {
 134       return GDCM_UNFOUND;
 135    }
 136    return it->second;
 137 }
 138 /**
 139  * \brief   Determines if the key passed corresponds to a 'Transfer Syntax'
 140  *          as defined in DICOM (and stored in gdcm::TS class)
 141  * @return  True when key is an actual 'Transfer Syntax'. False in all
 142  *          other cases.
 143  */
 144 bool TS::IsTransferSyntax(TSKey const &key)
 145 {
 146    TSHT::const_iterator it = TsMap.find(key);
 147    return it != TsMap.end();
 148 }
 149
 150 /**
 151  * \brief   Determines if the Transfer Syntax was already encountered
 152  *          and if it corresponds to a Run Length Encoding Lossless one
 153  * @return  True when Run Length Encoding Lossless found. False in all
 154  *          other cases.
 155  */
 156 bool TS::IsRLELossless(TSKey const &key)
 157 {
 158    bool r = false;
 159    // First check this is an actual transfer syntax
 160    if( IsTransferSyntax(key) )
 161    {
 162       if ( key == SpecialStrings[RLELossless] )
 163       {
 164          r = true;
 165       }
 166    }
 167    return r;
 168 }
 169
 170 /**
 171  * \brief   Determines if the Transfer Syntax was already encountered
 172  *          and if it corresponds to a 'classical' JPEG Lossless one
 173  * @return  True when 'classical' Lossless found. False in all
 174  *          other cases.
 175  */
 176 bool TS::IsJPEGLossless(TSKey const &key)
 177 {
 178    bool r = false;
 179    // First check this is an actual transfer syntax
 180    if( IsTransferSyntax(key) )
 181    {
 182       if ( key == SpecialStrings[JPEGFullProgressionProcess10_12]
 183         || key == SpecialStrings[JPEGLosslessProcess14]
 184         || key == SpecialStrings[JPEGLosslessProcess14_1] )
 185       {
 186          r = true;
 187       }
 188    }
 189    return r;
 190 }
 191
 192 /**
 193  * \brief   Determines if the Transfer Syntax was already encountered
 194  *          and if it corresponds to a 'classical' JPEG Lossy one
 195  * @return  True when 'classical' Lossy found. False in all
 196  *          other cases.
 197  */
 198 bool TS::IsJPEGLossy(TSKey const &key)
 199 {
 200    bool r = false;
 201    // First check this is an actual transfer syntax
 202    if( IsTransferSyntax(key) )
 203    {
 204       if ( key == SpecialStrings[JPEGBaselineProcess1]
 205         || key == SpecialStrings[JPEGExtendedProcess2_4]
 206         || key == SpecialStrings[JPEGExtendedProcess3_5]
 207         || key == SpecialStrings[JPEGSpectralSelectionProcess6_8] )
 208       {
 209          r = true;
 210       }
 211    }
 212    return r;
 213 }
 214
 215 /**
 216  * \brief   Determines if the Transfer Syntax was already encountered
 217  *          and if it corresponds to a JPEG2000 one
 218  * @return  True when JPEG2000 (Lossly or LossLess) found. False in all
 219  *          other cases.
 220  */
 221 bool TS::IsJPEG2000(TSKey const &key)
 222 {
 223    bool r = false;
 224    // First check this is an actual transfer syntax
 225    if( IsTransferSyntax(key) )
 226    {
 227       if ( key == SpecialStrings[JPEG2000Lossless]
 228         || key == SpecialStrings[JPEG2000] )
 229       {
 230          r = true;
 231       }
 232    }
 233    return r;
 234 }
 235
 236 /**
 237  * \brief   Determines if the Transfer Syntax corresponds to
 238  *          'classical' Jpeg Lossless or Jpeg lossy.
 239  * @return  True when any form of JPEG found. False otherwise.
 240  */
 241 bool TS::IsJPEG(TSKey const &key)
 242 {
 243    bool r = false;
 244    // First check this is an actual transfer syntax
 245    if( IsTransferSyntax(key) )
 246    {
 247       if ( IsJPEGLossy( key )
 248         || IsJPEGLossless( key )
 249          )
 250       {
 251          r = true;
 252       }
 253    }
 254    return r;
 255 }
 256
 257 /**
 258  * \brief   Determines if the Transfer Syntax corresponds to any form
 259  *          of Jpeg-LS encoded Pixel data.
 260  * @return  True when any form of JPEG-LS found. False otherwise.
 261  */
 262 bool TS::IsJPEGLS(TSKey const &key)
 263 {
 264    bool r = false;
 265    // First check this is an actual transfer syntax
 266    if( IsTransferSyntax(key) )
 267    {
 268       if ( key == SpecialStrings[JPEGLSLossless]
 269         || key == SpecialStrings[JPEGLSNearLossless] )
 270       {
 271          r = true;
 272       }
 273    }
 274    return r;
 275 }
 276
 277 TS::SpecialType TS::GetSpecialTransferSyntax(TSKey const &key)
 278 {
 279    for (int i = 0; SpecialStrings[i] != NULL; i++)
 280    {
 281       if ( SpecialStrings[i] == key )
 282       {
 283          return SpecialType(i);
 284       }
 285    }
 286
 287    return UnknownTS;
 288 }
 289
 290 const char* TS::GetSpecialTransferSyntax(SpecialType t)
 291 {
 292    return SpecialStrings[t];
 293 }
 294
 295 //-----------------------------------------------------------------------------
 296 // Protected
 297
 298 //-----------------------------------------------------------------------------
 299 // Private
 300
 301 //-----------------------------------------------------------------------------
 302 // Print
 303 /**
 304  * \brief   Print all
 305  * @param   os The output stream to be written to.
 306  */
 307 void TS::Print(std::ostream &os)
 308 {
 309    std::ostringstream s;
 310
 311    for (TSHT::const_iterator it = TsMap.begin(); it != TsMap.end(); ++it)
 312    {
 313       s << "TS : " << it->first << " = " << it->second << std::endl;
 314    }
 315    os << s.str();
 316 }
 317
 318 //-----------------------------------------------------------------------------
 319 } // end namespace gdcm