vega
Functions | Variables
vega::vr Namespace Reference

Functions

template<>
bool manipulator_is_valid_for< manipulators::AgeStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::ApplicationEntityManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::AttributeTagManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::CodeStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::DateManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::DateTimeManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::DecimalStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::EncapsulatedPixelDataManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::FloatingPointDoubleManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::FloatingPointManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::IntegerStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::LongStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::LongTextManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::OtherByteManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::OtherDoubleManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::OtherFloatManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::OtherLongManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::OtherWordManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::PersonNameManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::PixelDataManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::ShortStringManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::ShortTextManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::TimeManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UniqueIdentifierManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UnknownManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UnlimitedCharactersManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UnlimitedTextManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UnsignedLongManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::UnsignedShortManipulator > (VR::value_type value)
 
template<>
bool manipulator_is_valid_for< manipulators::URIManipulator > (VR::value_type value)
 
template<typename T >
bool manipulator_is_valid_for (VR::value_type value)
 
VR parse_vr_string (std::string s)
 

Variables

const VR::Data AE_DATA = {.characters = {'A', 'E'}}
 Application Entity. More...
 
const VR::value_type AE_VALUE = AE_DATA.value
 
const VR AE {AE_VALUE}
 
const VR::Data AS_DATA = {.characters = {'A', 'S'}}
 Age String. More...
 
const VR::value_type AS_VALUE = AS_DATA.value
 
const VR AS {AS_VALUE}
 
const VR::Data AT_DATA = {.characters = {'A', 'T'}}
 Attribute Tag. More...
 
const VR::value_type AT_VALUE = AT_DATA.value
 
const VR AT {AT_VALUE}
 
const VR::Data CS_DATA = {.characters = {'C', 'S'}}
 Code String. More...
 
const VR::value_type CS_VALUE = CS_DATA.value
 
const VR CS {CS_VALUE}
 
const VR::Data DA_DATA = {.characters = {'D', 'A'}}
 Date. More...
 
const VR::value_type DA_VALUE = DA_DATA.value
 
const VR DA {DA_VALUE}
 
const VR::Data DS_DATA = {.characters = {'D', 'S'}}
 Decimal String. More...
 
const VR::value_type DS_VALUE = DS_DATA.value
 
const VR DS {DS_VALUE}
 
const VR::Data DT_DATA = {.characters = {'D', 'T'}}
 Date Time. More...
 
const VR::value_type DT_VALUE = DT_DATA.value
 
const VR DT {DT_VALUE}
 
const VR::Data FD_DATA = {.characters = {'F', 'D'}}
 Floating Point Double. More...
 
const VR::value_type FD_VALUE = FD_DATA.value
 
const VR FD {FD_VALUE}
 
const VR::Data FL_DATA = {.characters = {'F', 'L'}}
 Floating Point Single. More...
 
const VR::value_type FL_VALUE = FL_DATA.value
 
const VR FL {FL_VALUE}
 
const VR::Data IS_DATA = {.characters = {'I', 'S'}}
 Integer String. More...
 
const VR::value_type IS_VALUE = IS_DATA.value
 
const VR IS {IS_VALUE}
 
const VR::Data LO_DATA = {.characters = {'L', 'O'}}
 Long String. More...
 
const VR::value_type LO_VALUE = LO_DATA.value
 
const VR LO {LO_VALUE}
 
const VR::Data LT_DATA = {.characters = {'L', 'T'}}
 Long Text. More...
 
const VR::value_type LT_VALUE = LT_DATA.value
 
const VR LT {LT_VALUE}
 
const VR::Data OB_DATA = {.characters = {'O', 'B'}}
 Other Byte String. More...
 
const VR::value_type OB_VALUE = OB_DATA.value
 
const VR OB {OB_VALUE}
 
const VR::Data OD_DATA = {.characters = {'O', 'D'}}
 Other Double String. More...
 
const VR::value_type OD_VALUE = OD_DATA.value
 
const VR OD {OD_VALUE}
 
const VR::Data OL_DATA = {.characters = {'O', 'L'}}
 
const VR::value_type OL_VALUE = OL_DATA.value
 
const VR OL {OL_VALUE}
 
const VR::Data OF_DATA = {.characters = {'O', 'F'}}
 Other Float String. More...
 
const VR::value_type OF_VALUE = OF_DATA.value
 
const VR OF {OF_VALUE}
 
const VR::Data OW_DATA = {.characters = {'O', 'W'}}
 Other Word String. More...
 
const VR::value_type OW_VALUE = OW_DATA.value
 
const VR OW {OW_VALUE}
 
const VR::Data PN_DATA = {.characters = {'P', 'N'}}
 Person Name. More...
 
const VR::value_type PN_VALUE = PN_DATA.value
 
const VR PN {PN_VALUE}
 
const VR::Data SH_DATA = {.characters = {'S', 'H'}}
 Short String. More...
 
const VR::value_type SH_VALUE = SH_DATA.value
 
const VR SH {SH_VALUE}
 
const VR::Data SL_DATA = {.characters = {'S', 'L'}}
 Signed Long. More...
 
const VR::value_type SL_VALUE = SL_DATA.value
 
const VR SL {SL_VALUE}
 
const VR::Data SQ_DATA = {.characters = {'S', 'Q'}}
 Sequence of Items. More...
 
const VR::value_type SQ_VALUE = SQ_DATA.value
 
const VR SQ {SQ_VALUE}
 
const VR::Data SS_DATA = {.characters = {'S', 'S'}}
 Signed Short. More...
 
const VR::value_type SS_VALUE = SS_DATA.value
 
const VR SS {SS_VALUE}
 
const VR::Data ST_DATA = {.characters = {'S', 'T'}}
 Short Text. More...
 
const VR::value_type ST_VALUE = ST_DATA.value
 
const VR ST {ST_VALUE}
 
const VR::Data TM_DATA = {.characters = {'T', 'M'}}
 Time. More...
 
const VR::value_type TM_VALUE = TM_DATA.value
 
const VR TM {TM_VALUE}
 
const VR::Data UC_DATA = {.characters = {'U', 'C'}}
 
const VR::value_type UC_VALUE = UC_DATA.value
 
const VR UC {UC_VALUE}
 
const VR::Data UI_DATA = {.characters = {'U', 'I'}}
 Unique Identifier (UID) More...
 
const VR::value_type UI_VALUE = UI_DATA.value
 
const VR UI {UI_VALUE}
 
const VR::Data UL_DATA = {.characters = {'U', 'L'}}
 Unsigned Long. More...
 
const VR::value_type UL_VALUE = UL_DATA.value
 
const VR UL {UL_VALUE}
 
const VR::Data UN_DATA = {.characters = {'U', 'N'}}
 Unknown. More...
 
const VR::value_type UN_VALUE = UN_DATA.value
 
const VR UN {UN_VALUE}
 
const VR::Data UR_DATA = {.characters = {'U', 'R'}}
 
const VR::value_type UR_VALUE = UR_DATA.value
 
const VR UR {UR_VALUE}
 
const VR::Data US_DATA = {.characters = {'U', 'S'}}
 Unsigned Short. More...
 
const VR::value_type US_VALUE = US_DATA.value
 
const VR US {US_VALUE}
 
const VR::Data UT_DATA = {.characters = {'U', 'T'}}
 Unlimited Text. More...
 
const VR::value_type UT_VALUE = UT_DATA.value
 
const VR UT {UT_VALUE}
 
const VR::Data OX_DATA = {.characters = {'o', 'x'}}
 
const VR::value_type OX_VALUE = OX_DATA.value
 
const VR OX {OX_VALUE}
 
const VR::Data XS_DATA = {.characters = {'x', 's'}}
 
const VR::value_type XS_VALUE = XS_DATA.value
 
const VR XS {XS_VALUE}
 
const VR::Data XW_DATA = {.characters = {'x', 'w'}}
 
const VR::value_type XW_VALUE = XW_DATA.value
 
const VR XW {XW_VALUE}
 
const VR::Data UW_DATA = {.characters = {'u', 'w'}}
 
const VR::value_type UW_VALUE = UW_DATA.value
 
const VR UW {UW_VALUE}
 

Function Documentation

◆ manipulator_is_valid_for()

template<typename T >
bool vega::vr::manipulator_is_valid_for ( VR::value_type  value)

◆ manipulator_is_valid_for< manipulators::AgeStringManipulator >()

◆ manipulator_is_valid_for< manipulators::ApplicationEntityManipulator >()

◆ manipulator_is_valid_for< manipulators::AttributeTagManipulator >()

◆ manipulator_is_valid_for< manipulators::CodeStringManipulator >()

◆ manipulator_is_valid_for< manipulators::DateManipulator >()

◆ manipulator_is_valid_for< manipulators::DateTimeManipulator >()

◆ manipulator_is_valid_for< manipulators::DecimalStringManipulator >()

◆ manipulator_is_valid_for< manipulators::EncapsulatedPixelDataManipulator >()

◆ manipulator_is_valid_for< manipulators::FloatingPointDoubleManipulator >()

◆ manipulator_is_valid_for< manipulators::FloatingPointManipulator >()

◆ manipulator_is_valid_for< manipulators::IntegerStringManipulator >()

◆ manipulator_is_valid_for< manipulators::LongStringManipulator >()

◆ manipulator_is_valid_for< manipulators::LongTextManipulator >()

◆ manipulator_is_valid_for< manipulators::OtherByteManipulator >()

◆ manipulator_is_valid_for< manipulators::OtherDoubleManipulator >()

◆ manipulator_is_valid_for< manipulators::OtherFloatManipulator >()

◆ manipulator_is_valid_for< manipulators::OtherLongManipulator >()

◆ manipulator_is_valid_for< manipulators::OtherWordManipulator >()

◆ manipulator_is_valid_for< manipulators::PersonNameManipulator >()

◆ manipulator_is_valid_for< manipulators::PixelDataManipulator >()

◆ manipulator_is_valid_for< manipulators::ShortStringManipulator >()

◆ manipulator_is_valid_for< manipulators::ShortTextManipulator >()

◆ manipulator_is_valid_for< manipulators::TimeManipulator >()

◆ manipulator_is_valid_for< manipulators::UniqueIdentifierManipulator >()

◆ manipulator_is_valid_for< manipulators::UnknownManipulator >()

◆ manipulator_is_valid_for< manipulators::UnlimitedCharactersManipulator >()

◆ manipulator_is_valid_for< manipulators::UnlimitedTextManipulator >()

◆ manipulator_is_valid_for< manipulators::UnsignedLongManipulator >()

◆ manipulator_is_valid_for< manipulators::UnsignedShortManipulator >()

◆ manipulator_is_valid_for< manipulators::URIManipulator >()

◆ parse_vr_string()

VR vega::vr::parse_vr_string ( std::string  s)

Variable Documentation

◆ AE

const VR vega::vr::AE {AE_VALUE}

◆ AE_DATA

const VR::Data vega::vr::AE_DATA = {.characters = {'A', 'E'}}

Application Entity.

A string of characters that identifies an Application Entity with leading and trailer spaces (0x20) being non-significant. A value consisting soley of spaces shall not be used.

16 bytes maximum (string) (padded by space)

◆ AE_VALUE

const VR::value_type vega::vr::AE_VALUE = AE_DATA.value

◆ AS

const VR vega::vr::AS {AS_VALUE}

◆ AS_DATA

const VR::Data vega::vr::AS_DATA = {.characters = {'A', 'S'}}

Age String.

A string of characters with one of the following formats - nnnD, nnnW, nnnM, nnnY; where nnn shall contain the number of days for D, weeks for W, months for M, or years for Y.

Example: "018M" would represent an age of 18 months.

4 bytes fixed (formatted string)

◆ AS_VALUE

const VR::value_type vega::vr::AS_VALUE = AS_DATA.value

◆ AT

const VR vega::vr::AT {AT_VALUE}

◆ AT_DATA

const VR::Data vega::vr::AT_DATA = {.characters = {'A', 'T'}}

Attribute Tag.

Ordered pair of 16-bit unsigned integers that is the value of a Data Element Tag.

4 bytes fixed (pair UINT2)

◆ AT_VALUE

const VR::value_type vega::vr::AT_VALUE = AT_DATA.value

◆ CS

const VR vega::vr::CS {CS_VALUE}

◆ CS_DATA

const VR::Data vega::vr::CS_DATA = {.characters = {'C', 'S'}}

Code String.

A string of characters with leading or trailing spaces (0x20) being non-significant.

16 bytes maximum (string) (padded by space)

◆ CS_VALUE

const VR::value_type vega::vr::CS_VALUE = CS_DATA.value

◆ DA

const VR vega::vr::DA {DA_VALUE}

◆ DA_DATA

const VR::Data vega::vr::DA_DATA = {.characters = {'D', 'A'}}

Date.

A string of characters of the format yyyymmdd; where yyyy shall contain year, mm shall contain month, and dd shall contain the day. This conforms to the ANSI HISPP MSDS Date common data type.

8 bytes fixed (formatted string)

◆ DA_VALUE

const VR::value_type vega::vr::DA_VALUE = DA_DATA.value

◆ DS

const VR vega::vr::DS {DS_VALUE}

◆ DS_DATA

const VR::Data vega::vr::DS_DATA = {.characters = {'D', 'S'}}

Decimal String.

A string of characters representing either a fixed point number or a floating point number. A fixed point number shall contain only the characters 0-9 with an optional leading '+' or '-' and an optional '.' to mark the decimal point. A floating point number shall be conveyed as defined in ANSI X3.9, with and 'E' or 'e' to indicate the start of the exponent. Decimal Strings may be padded with leading or trailing spaces. Embedded spaces are not allowed.

16 bytes maximum (decimal string) (padded by space)

◆ DS_VALUE

const VR::value_type vega::vr::DS_VALUE = DS_DATA.value

◆ DT

const VR vega::vr::DT {DT_VALUE}

◆ DT_DATA

const VR::Data vega::vr::DT_DATA = {.characters = {'D', 'T'}}

Date Time.

The Date Time common data type. Indicates a concatenated date-time ASCII string in the format YYYYMMDDHHMMSS.FFFFFF&ZZZZ. The components of this string, from left to right, are YYYY = Year, MM = Month, DD = Day, HH = Hour, MM = Minute, SS = Second, FFFFFF = Fraction Second, & = '+' or '-', and ZZZZ = Hours and Minutes of offset. &ZZZZ is an optional suffix for plus/minus offset from Coordinated Universal Time. A component that is omitted from the string is termed a null componennt. Trailing null components of Date Time are ignored. Non-trailing null components are prohibited, given that the optional suffix is not considered as a component.

26 bytes maximum (formatted string)

◆ DT_VALUE

const VR::value_type vega::vr::DT_VALUE = DT_DATA.value

◆ FD

const VR vega::vr::FD {FD_VALUE}

◆ FD_DATA

const VR::Data vega::vr::FD_DATA = {.characters = {'F', 'D'}}

Floating Point Double.

Double precision binary floating point number represented in IEEE 754: 1985 64-bit Floating Point Number Format.

8 bytes fixed (double)

◆ FD_VALUE

const VR::value_type vega::vr::FD_VALUE = FD_DATA.value

◆ FL

const VR vega::vr::FL {FL_VALUE}

◆ FL_DATA

const VR::Data vega::vr::FL_DATA = {.characters = {'F', 'L'}}

Floating Point Single.

Single precision binary floating point number represented in IEEE 754: 1985 32-bit Floating Point Number Format.

4 bytes fixed (float)

◆ FL_VALUE

const VR::value_type vega::vr::FL_VALUE = FL_DATA.value

◆ IS

const VR vega::vr::IS {IS_VALUE}

◆ IS_DATA

const VR::Data vega::vr::IS_DATA = {.characters = {'I', 'S'}}

Integer String.

A string of characters representing an Integer in base-10 (decimal), shall contain only the characters 0-9, with an optional leading '+' or '-'. It may be padded with leading and/or trailing spaces. Embedded spaces are not allowed. The integer shall be in the range: (-2^31) to (2^31 - 1) inclusively.

12 bytes maximum (integer string) (padded by space)

◆ IS_VALUE

const VR::value_type vega::vr::IS_VALUE = IS_DATA.value

◆ LO

const VR vega::vr::LO {LO_VALUE}

◆ LO_DATA

const VR::Data vega::vr::LO_DATA = {.characters = {'L', 'O'}}

Long String.

A character string that may be padded with leading and/or trailing spaces. The character backslash '\' shall not be present, as it is used as the delimiter between values in multiple valued data elements. The string shall not have Control Characters except for ESC.

64 chars maximum (string) (padded by space)

◆ LO_VALUE

const VR::value_type vega::vr::LO_VALUE = LO_DATA.value

◆ LT

const VR vega::vr::LT {LT_VALUE}

◆ LT_DATA

const VR::Data vega::vr::LT_DATA = {.characters = {'L', 'T'}}

Long Text.

A character string that may contain one or more paragraphs. It may contain the Graphic Character set and the Control Characters, CR, LF, FF, and ESC. It may be padded with trailing spaces, which may be ignored, but leading spaces are considered to be significant. Data Elements with this VR shall not be multi-valued and therefore character backslash '\' may be used.

10240 chars maximum (string) (padded by space)

◆ LT_VALUE

const VR::value_type vega::vr::LT_VALUE = LT_DATA.value

◆ OB

const VR vega::vr::OB {OB_VALUE}

◆ OB_DATA

const VR::Data vega::vr::OB_DATA = {.characters = {'O', 'B'}}

Other Byte String.

A string of bytes where the encoding of the contents is specified by the negotiated Transfer Syntax. The string of bytes shall be padded with a single trailing NULL byte when necessary to achieve even length.

see Transfer Syntax definition (bytes - use hex) (padded by NULL)

◆ OB_VALUE

const VR::value_type vega::vr::OB_VALUE = OB_DATA.value

◆ OD

const VR vega::vr::OD {OD_VALUE}

◆ OD_DATA

const VR::Data vega::vr::OD_DATA = {.characters = {'O', 'D'}}

Other Double String.

A string of 64-bit IEEE 754:1985 floating point words. OD is a VR that requires byte swapping within each 64-bit word when changing between Little Endian and Big Endian byte ordering

◆ OD_VALUE

const VR::value_type vega::vr::OD_VALUE = OD_DATA.value

◆ OF

const VR vega::vr::OF {OF_VALUE}

◆ OF_DATA

const VR::Data vega::vr::OF_DATA = {.characters = {'O', 'F'}}

Other Float String.

A string of 32-bit IEEE 754: 1985 floating point words.

2^32-4 maximum (4 byte words - hex)

◆ OF_VALUE

const VR::value_type vega::vr::OF_VALUE = OF_DATA.value

◆ OL

const VR vega::vr::OL {OL_VALUE}

◆ OL_DATA

const VR::Data vega::vr::OL_DATA = {.characters = {'O', 'L'}}

◆ OL_VALUE

const VR::value_type vega::vr::OL_VALUE = OL_DATA.value

◆ OW

const VR vega::vr::OW {OW_VALUE}

◆ OW_DATA

const VR::Data vega::vr::OW_DATA = {.characters = {'O', 'W'}}

Other Word String.

A string of 16-bit words where the encoding of the contents is specified by the negotiated Transfer Syntax.

see Transfer Syntax definition (2 byte words - hex)

◆ OW_VALUE

const VR::value_type vega::vr::OW_VALUE = OW_DATA.value

◆ OX

const VR vega::vr::OX {OX_VALUE}

◆ OX_DATA

const VR::Data vega::vr::OX_DATA = {.characters = {'o', 'x'}}

◆ OX_VALUE

const VR::value_type vega::vr::OX_VALUE = OX_DATA.value

◆ PN

const VR vega::vr::PN {PN_VALUE}

◆ PN_DATA

const VR::Data vega::vr::PN_DATA = {.characters = {'P', 'N'}}

Person Name.

Todo:
Document person name VR

64 chars maximum per component group (string) (padded by space)

◆ PN_VALUE

const VR::value_type vega::vr::PN_VALUE = PN_DATA.value

◆ SH

const VR vega::vr::SH {SH_VALUE}

◆ SH_DATA

const VR::Data vega::vr::SH_DATA = {.characters = {'S', 'H'}}

Short String.

A character string that may be padded with leading and/or trailer spaces. The character backslash '\' shall not be present, as it is used as the delimiter between values for multiple data elements. The string shall not have Control Characters except ESC.

16 chars maximum (string) (padded by space)

◆ SH_VALUE

const VR::value_type vega::vr::SH_VALUE = SH_DATA.value

◆ SL

const VR vega::vr::SL {SL_VALUE}

◆ SL_DATA

const VR::Data vega::vr::SL_DATA = {.characters = {'S', 'L'}}

Signed Long.

Signed binaryt integer 32 bits long in 2's complement form. Represents an integer in the range (-2^31) to (2^31 - 1) inclusively.

4 bytes maximum (INT4)

◆ SL_VALUE

const VR::value_type vega::vr::SL_VALUE = SL_DATA.value

◆ SQ

const VR vega::vr::SQ {SQ_VALUE}

◆ SQ_DATA

const VR::Data vega::vr::SQ_DATA = {.characters = {'S', 'Q'}}

Sequence of Items.

The value field is a sequence of zero or more items.

◆ SQ_VALUE

const VR::value_type vega::vr::SQ_VALUE = SQ_DATA.value

◆ SS

const VR vega::vr::SS {SS_VALUE}

◆ SS_DATA

const VR::Data vega::vr::SS_DATA = {.characters = {'S', 'S'}}

Signed Short.

Signed binary integer 16 bits long in 2's complement form. Represents an integer in the range (-2^15) to (2^15 - 1) inclusively.

2 bytes fixed (INT2)

◆ SS_VALUE

const VR::value_type vega::vr::SS_VALUE = SS_DATA.value

◆ ST

const VR vega::vr::ST {ST_VALUE}

◆ ST_DATA

const VR::Data vega::vr::ST_DATA = {.characters = {'S', 'T'}}

Short Text.

A character string that may contain one or more paragraphs. It may contain the Graphic Character set and the Control Characters, CR, LF, FF, and ESC. It may be padded with trailing spaces, which may be ignored, but leading spaces are considered significant. Data Elements with this VR shall not be multi-valued and therefore character backslash '\' may be used.

1024 chars maximum (string) (padded by space)

◆ ST_VALUE

const VR::value_type vega::vr::ST_VALUE = ST_DATA.value

◆ TM

const VR vega::vr::TM {TM_VALUE}

◆ TM_DATA

const VR::Data vega::vr::TM_DATA = {.characters = {'T', 'M'}}

Time.

A string of characters of the format hhmmss.frac; where hh contains hours (range 00 to 23), mm contains minutes (range 00 to 59), ss contains seconds (range 00 to 59), and frac contains a fractional part of a second as small as 1 millionth of a second (range 000000 to 999999). A 24 hour clock is assumed. Midnight can be represented by only 0000 since 2400 would violate the hour range. The string may be padded with trailing spaces. Leading and embedded spaces are not allowed. One or more of the components mm, ss, or frac may be unspecified as long as every component to the right of an unspecified component is also unspecified. If frac is unspecified the preceding '.' may not be included.

16 bytes maximum (formatted string) (padded by space)

◆ TM_VALUE

const VR::value_type vega::vr::TM_VALUE = TM_DATA.value

◆ UC

const VR vega::vr::UC {UC_VALUE}

◆ UC_DATA

const VR::Data vega::vr::UC_DATA = {.characters = {'U', 'C'}}

◆ UC_VALUE

const VR::value_type vega::vr::UC_VALUE = UC_DATA.value

◆ UI

const VR vega::vr::UI {UI_VALUE}

◆ UI_DATA

const VR::Data vega::vr::UI_DATA = {.characters = {'U', 'I'}}

Unique Identifier (UID)

A character string containing a UID that is used to uniquely identify a wide variety of items. The UID is a series of numeric components separated by the period '.' character. If a Value Field containing one or more UIDs is an odd number of bytes in length, the Value Field shall be padded with a single trailing NULL character to ensure that the Value Field is an even number of bytes in length.

64 bytes maximum (string) (padded by NULL)

◆ UI_VALUE

const VR::value_type vega::vr::UI_VALUE = UI_DATA.value

◆ UL

const VR vega::vr::UL {UL_VALUE}

◆ UL_DATA

const VR::Data vega::vr::UL_DATA = {.characters = {'U', 'L'}}

Unsigned Long.

Unsigned binary integer 32 bits long. Represents an integer in the range 0 to 2^32 inclusively.

4 bytes maximum (UINT4)

◆ UL_VALUE

const VR::value_type vega::vr::UL_VALUE = UL_DATA.value

◆ UN

const VR vega::vr::UN {UN_VALUE}

◆ UN_DATA

const VR::Data vega::vr::UN_DATA = {.characters = {'U', 'N'}}

Unknown.

A string of bytes where the encoding of the contents is unknown. Any length that is valid for any of the other DICOM Value Representations is also valid for UN (string)

◆ UN_VALUE

const VR::value_type vega::vr::UN_VALUE = UN_DATA.value

◆ UR

const VR vega::vr::UR {UR_VALUE}

◆ UR_DATA

const VR::Data vega::vr::UR_DATA = {.characters = {'U', 'R'}}

◆ UR_VALUE

const VR::value_type vega::vr::UR_VALUE = UR_DATA.value

◆ US

const VR vega::vr::US {US_VALUE}

◆ US_DATA

const VR::Data vega::vr::US_DATA = {.characters = {'U', 'S'}}

Unsigned Short.

Unsigned binary integer 16 bits long. Represents an integer in the range 0 to 2^16 inclusively.

2 bytes fixed (UINT2)

◆ US_VALUE

const VR::value_type vega::vr::US_VALUE = US_DATA.value

◆ UT

const VR vega::vr::UT {UT_VALUE}

◆ UT_DATA

const VR::Data vega::vr::UT_DATA = {.characters = {'U', 'T'}}

Unlimited Text.

A character string that may contain one or more paragraphs. It may contain the Graphic Character set and the Control Characters, CR, LF, FF, and ESC. It may be padded with trailing spaces, which may be ignored, but leading spaces are considered to be significant. Data Elements with this VR shall not be multi-valued and there for character backslash '\' may be used.

2^32-2 limited by the size of the maximum unsigned integer representable in a 32 bit field minus one since 0xFFFFFFFF is reserved (padded by space)

◆ UT_VALUE

const VR::value_type vega::vr::UT_VALUE = UT_DATA.value

◆ UW

const VR vega::vr::UW {UW_VALUE}

◆ UW_DATA

const VR::Data vega::vr::UW_DATA = {.characters = {'u', 'w'}}

◆ UW_VALUE

const VR::value_type vega::vr::UW_VALUE = UW_DATA.value

◆ XS

const VR vega::vr::XS {XS_VALUE}

◆ XS_DATA

const VR::Data vega::vr::XS_DATA = {.characters = {'x', 's'}}

◆ XS_VALUE

const VR::value_type vega::vr::XS_VALUE = XS_DATA.value

◆ XW

const VR vega::vr::XW {XW_VALUE}

◆ XW_DATA

const VR::Data vega::vr::XW_DATA = {.characters = {'x', 'w'}}

◆ XW_VALUE

const VR::value_type vega::vr::XW_VALUE = XW_DATA.value