Enum VirtualVr

#[non_exhaustive]
pub enum VirtualVr {
    Exact(VR),
    Xs,
    Ox,
    Px,
    Lt,
}

A “virtual” value representation (VR) descriptor which extends the standard enumeration with context-dependent VRs.

It is used by element dictionary entries to describe circumstances in which the real VR may depend on context. As an example, the Pixel Data attribute can have a value representation of either OB or OW.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Exact(VR)

The value representation is exactly known and does not depend on context.

Xs

Represents a pixel data sample value with a short magnitude.

The value representation depends on the pixel data value sample representation. If pixel data values are signed (represented by a Pixel Representation value of 1), then values with this virtual VR should be interpreted as signed 16 bit integers (SS), otherwise they should be interpreted as unsigned 16 bit integers (US).

Ox

Represents overlay data sample values.

It can be either OB or OW.

Px

Represents pixel data sample value.

It can be either OB or OW.

Lt

Represents LUT data, which can be US or OW

Implementations

impl VirtualVr

pub fn exact(self) -> Option<VR>

Return the underlying value representation in the case that it can be unambiguously defined without context.

pub fn relaxed(self) -> VR

Return the underlying value representation, making a relaxed conversion if it cannot be accurately resolved without context.

• Xs is relaxed to US
• Ox is relaxed to OW
• Px is relaxed to OW
• Lt is relaxed to OW

This method is ill-advised for uses where the corresponding attribute is important.

Trait Implementations

impl Clone for VirtualVr

fn clone(&self) -> VirtualVr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VirtualVr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<VR> for VirtualVr

fn from(value: VR) -> Self

Converts to this type from the input type.

impl Hash for VirtualVr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for VirtualVr

fn eq(&self, other: &VirtualVr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for VirtualVr

impl Eq for VirtualVr

impl StructuralPartialEq for VirtualVr