MeVis/Foundation/Sources/DicomTree/MLDicomTree/DCMTree_Lib.h

Go to the documentation of this file.

//----------------------------------------------------------------------------------
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef HEADER_DCMTREE_LIB
#define HEADER_DCMTREE_LIB

#ifdef _MSC_VER
  // Disable some boost and system header warnings.
  // 4265: 'boost::exception_detail::error_info_container' : class has virtual functions, but destructor is not virtual
  // 4365: signed/unsigned mismatch
  // 4548: expression before comma has no effect; expected expression with side-effect
  // 4619: #pragma warning : there is no warning number '4284'
  #pragma warning (push)
  #pragma warning (disable : 4265 4365 4548 4619)
#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

#if defined (WIN32) && (_MSC_VER <= 1200) && defined(_XTREE_)
# pragma message("You do not have a patched XTREE file from $(MLAB_MeVisLab_Foundation)\\BuildTools\\win32\\patches\\msvc6\\XTREE or http://www.dinkumware.com/vc_fixes.html installed.")
# pragma message("Replace the old XTREE file in 'Program Files\\Microsoft Visual Studio\\VC98\\Include' with the patched version.")
# error "YOUR MODULE WILL NOT WORK."
#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 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, 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
    };

    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