DCMTree_Lib.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef DCM_TREE_LIB_H
#define DCM_TREE_LIB_H
 
#ifdef _MSC_VER
  // Disable some boost and system header warnings.
  // 4242: conversion from "a" to "b", possible loss of data
  // 4265: 'boost::exception_detail::error_info_container' : class has virtual functions, but destructor is not virtual
  // 4350: behaviour change
  // 4365: signed/unsigned mismatch
  // 4512: assignment operator could not be generate
  // 4548: expression before comma has no effect; expected expression with side-effect
  // 4619: #pragma warning : there is no warning number '4284'
  // 4623: default constructor was implicitly defined as deleted because a base class default constructor is inaccessible or deleted
  #pragma warning (push)
  #pragma warning (disable : 4242 4265 4350 4365 4512 4548 4619 4623)
#endif
 
#include <utility>
#include <map>
#include <vector>
#include <string>
 
#include <boost/smart_ptr.hpp>
 
#if defined (__GNUC__) && (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 3)
  // Including string.h here is required since gcc version 4.3. Older gcc
  // versions provide it in a header file that is not included.
  #include <string.h>
#endif
 
#ifdef _MSC_VER
  #pragma warning (pop)
#endif
 
#include "DCMTree_Defines.h"
#include "DCMTree_Serialization.h"
 
 
namespace DCMTree
{
    class Tag;
 
    typedef boost::shared_ptr<Tag> TagPtr;
    typedef boost::shared_ptr<const Tag> Const_TagPtr;
 
    class MFPixelTag;
    typedef boost::shared_ptr<MFPixelTag> MFPixelTagPtr;
    typedef boost::shared_ptr<const MFPixelTag> Const_MFPixelTagPtr;
 
    class Tree;
    typedef boost::shared_ptr<Tree> TreePtr;
    typedef boost::shared_ptr<const Tree> Const_TreePtr;
 
    class Message;
    typedef boost::shared_ptr<Message> MessagePtr;
    typedef boost::shared_ptr<const Message> Const_MessagePtr;
 
    class TagInfo;
    typedef boost::shared_ptr<TagInfo> TagInfoPtr;
    typedef boost::shared_ptr<const TagInfo> Const_TagInfoPtr;
 
    typedef std::vector<TreePtr> TreePtrVector;
 
    class Value;
 
    typedef boost::shared_ptr<Value> ValuePtr;
    typedef boost::shared_ptr<const Value> Const_ValuePtr;
 
    class CharacterSetConverter;
 
    typedef boost::shared_ptr<CharacterSetConverter> CharacterSetConverterPtr;
    typedef boost::shared_ptr<const CharacterSetConverter> Const_CharacterSetConverterPtr;
 
    typedef boost::shared_array<unsigned char> pixel_cont_t;
 
    struct PixelData {
      PixelData() : _data(nullptr) {};
      PixelData(const pixel_cont_t& data) : _data(data.get()),_sharedData(data) {};
      PixelData(const unsigned char* data) : _data(data), _sharedData(pixel_cont_t()) {};
 
      operator bool() const {
        return _data != nullptr;
      }
 
      void operator=(const pixel_cont_t& data) {
        _data = data.get();
        _sharedData = data;
      }
 
      void operator=(unsigned char* data) {
        _data = data;
        _sharedData = pixel_cont_t();
      }
 
      const unsigned char* get() const { return _data; }
 
    private:
      const unsigned char* _data;
      pixel_cont_t _sharedData;
    };
 
    class Dict;
 
    typedef boost::shared_ptr<Dict> DictPtr;
    typedef boost::shared_ptr<const Dict> Const_DictPtr;
 
    class Exception;
 
    typedef boost::shared_ptr<Exception> ExceptionPtr;
    typedef boost::shared_ptr<const Exception> Const_ExceptionPtr;
 
    class TagId;
    typedef boost::shared_ptr<TagId> TagIdPtr;
    typedef std::pair<TagIdPtr,TagIdPtr> TagIdPtrPair;
    typedef unsigned int RawTagId;
 
    typedef std::vector<TagId> TagIdVector;
 
    typedef boost::shared_ptr<TagIdVector> TagIdVectorPtr;
    typedef boost::shared_ptr<const TagIdVector> Const_TagIdVectorPtr;
 
    typedef std::map<TagId,TagPtr> TagPtrMap;
    typedef std::map<TagId,Const_TagPtr> Const_TagPtrMap;
    typedef boost::shared_ptr<Const_TagPtrMap> Const_TagPtrMapPtr;
 
    class Reader;
 
    typedef boost::shared_ptr<Reader> ReaderPtr;
    typedef boost::shared_ptr<const Reader> Const_ReaderPtr;
 
    class StructuredMF;
    typedef boost::shared_ptr<StructuredMF> StructuredMFPtr;
    typedef boost::shared_ptr<const StructuredMF> Const_StructuredMFPtr;
 
    typedef std::pair<unsigned,unsigned> TagValueMultiplicity;
 
    class IOParameter;
    typedef boost::shared_ptr<IOParameter> IOParameterPtr;
 
    struct DCMTREE_EXPORT Date
    {
        Date( int year = 0, int month = 0, int day = 0 );
 
        unsigned short _year;   // 0000-9999
        unsigned char _month; // 00-12
        unsigned char _day;     // 00-31
    };
 
    struct DCMTREE_EXPORT Time
    {
        Time( int hour = 0, int minute = 0, int second = 0, int msec = 0 );
 
        unsigned char _hour; // 00-23
        unsigned char _minute; // 00-59
        unsigned char _second; // 00-59
        double _fraction; // 0.0-0.999999
    };
 
    typedef std::pair<Date,Time> DateTime;
 
    enum Vr
    {
        AE, AS, CS, DA, DS, DT, IS, LO, LT, PN, SH, ST, TM, UT,
        UI, SS, US, AT, SL, UL, FL, FD,  OB, OW, OL, OF, SQ, UN, UR, OD, UC, VRCOUNT
    };
 
    typedef std::vector<Vr> VrVector;
 
    enum VRCType
    {
        TY_String,TY_Date,TY_DateTime,TY_Time,
        TY_Float,TY_Double,TY_Seq,TY_Int,
        TY_UInt,TY_Short,TY_UShort,TY_Bin,
        TY_Att
    };
 
    enum ErrorCode
    {
        NoError,  // warning only
        MissingTag,
        InvalidData,
        WritingDataFailed
    };
 
    DCMTREE_EXPORT bool isType (Vr vr, VRCType vrctype);
 
    enum TransferSyntax
    {
        INVALID_TRANSFER_SYNTAX,
        IMPLICIT_LITTLE_ENDIAN,
        EXPLICIT_LITTLE_ENDIAN,
        EXPLICIT_BIG_ENDIAN,
        IMPLICIT_BIG_ENDIAN,
        DEFLATED_EXPLICIT_LITTLE_ENDIAN,
        RLE,
        JPEG_BASELINE,
        JPEG_EXTENDED_2_4,
        JPEG_EXTENDED_3_5,
        JPEG_SPEC_NON_HIER_6_8,
        JPEG_SPEC_NON_HIER_7_9,
        JPEG_FULL_PROG_NON_HIER_10_12,
        JPEG_FULL_PROG_NON_HIER_11_13,
        JPEG_LOSSLESS_NON_HIER_14,
        JPEG_LOSSLESS_NON_HIER_15,
        JPEG_EXTENDED_HIER_16_18,
        JPEG_EXTENDED_HIER_17_19,
        JPEG_SPEC_HIER_20_22,
        JPEG_SPEC_HIER_21_23,
        JPEG_FULL_PROG_HIER_24_26,
        JPEG_FULL_PROG_HIER_25_27,
        JPEG_LOSSLESS_HIER_28,
        JPEG_LOSSLESS_HIER_29,
        JPEG_LOSSLESS_HIER_14,
        JPEG_2000_LOSSLESS_ONLY,
        JPEG_2000,
        JPEG_LS_LOSSLESS,
        JPEG_LS_LOSSY,
        MPEG2_MPML,
        JPEG_2000_MC_LOSSLESS_ONLY,
        JPEG_2000_MC
    };
 
    enum TagSelector
    {
        AllTags,   
        NonRoot,   
        Owned      
    };
 
    TransferSyntax defaultTransferSyntax();
 
    DCMTREE_EXPORT std::string toString (const Vr vr);
 
    DCMTREE_EXPORT Vr toVr (const std::string &vrstr);
 
    DCMTREE_EXPORT bool isValidVrStr (const std::string &vrstr);
 
    DCMTREE_EXPORT std::string toString (const TransferSyntax syntax);
 
    DCMTREE_EXPORT std::string toString (const TagValueMultiplicity &mult);
}
 
namespace DCMTree_Serialization
{
    void serializeX (Sink &sink,const DCMTree::TransferSyntax &syntax);
    void deserializeX (Source &source,DCMTree::TransferSyntax &syntax);
    void serializeX (Sink &sink,const DCMTree::Vr &vr);
    void deserializeX (Source &source,DCMTree::Vr &vr);
}
 
#endif