kcenon::pacs::encoding Namespace Reference

Namespaces
namespace	compression
namespace	simd

Classes
struct	character_set_info
	Information about a DICOM character set. More...
class	explicit_vr_big_endian_codec
	Encoder/decoder for Explicit VR Big Endian transfer syntax. More...
class	explicit_vr_codec
	Encoder/decoder for Explicit VR Little Endian transfer syntax. More...
class	implicit_vr_codec
	Encoder/decoder for Implicit VR Little Endian transfer syntax. More...
struct	specific_character_set
	Parsed representation of a multi-valued Specific Character Set. More...
struct	text_segment
	A text segment with its associated character set. More...
class	transfer_syntax
	Represents a DICOM Transfer Syntax. More...
struct	vr_info
	Metadata structure containing comprehensive VR properties. More...

Enumerations
enum class	byte_order { little_endian , big_endian }
	Byte ordering for DICOM data encoding. More...
enum class	vr_encoding { implicit , explicit_vr }
	Value Representation encoding mode. More...
enum class	vr_type : uint16_t {   AE = 0x4145 , AS = 0x4153 , CS = 0x4353 , DA = 0x4441 ,   DS = 0x4453 , DT = 0x4454 , IS = 0x4953 , LO = 0x4C4F ,   LT = 0x4C54 , PN = 0x504E , SH = 0x5348 , ST = 0x5354 ,   TM = 0x544D , UC = 0x5543 , UI = 0x5549 , UR = 0x5552 ,   UT = 0x5554 , FL = 0x464C , FD = 0x4644 , SL = 0x534C ,   SS = 0x5353 , UL = 0x554C , US = 0x5553 , OB = 0x4F42 ,   OD = 0x4F44 , OF = 0x4F46 , OL = 0x4F4C , OV = 0x4F56 ,   OW = 0x4F57 , UN = 0x554E , AT = 0x4154 , SQ = 0x5351 ,   SV = 0x5356 , UV = 0x5556 }
	DICOM Value Representation (VR) types. More...

Functions
std::string	get_decoded_string (const core::dicom_dataset &ds, core::dicom_tag tag, std::string_view default_value="")
	Get a string value from dataset, decoded to UTF-8.
void	set_encoded_string (core::dicom_dataset &ds, core::dicom_tag tag, vr_type vr, std::string_view utf8_value)
	Set a string value in dataset, encoding from UTF-8.
Single Value Byte Swapping
constexpr uint16_t	byte_swap16 (uint16_t value) noexcept
	Swaps bytes in a 16-bit value.
constexpr uint32_t	byte_swap32 (uint32_t value) noexcept
	Swaps bytes in a 32-bit value.
constexpr uint64_t	byte_swap64 (uint64_t value) noexcept
	Swaps bytes in a 64-bit value.
Big Endian Read/Write Functions
constexpr uint16_t	read_be16 (const uint8_t *data) noexcept
	Reads a 16-bit value from big-endian bytes.
constexpr uint32_t	read_be32 (const uint8_t *data) noexcept
	Reads a 32-bit value from big-endian bytes.
constexpr uint64_t	read_be64 (const uint8_t *data) noexcept
	Reads a 64-bit value from big-endian bytes.
void	write_be16 (std::vector< uint8_t > &buffer, uint16_t value)
	Writes a 16-bit value in big-endian byte order.
void	write_be32 (std::vector< uint8_t > &buffer, uint32_t value)
	Writes a 32-bit value in big-endian byte order.
void	write_be64 (std::vector< uint8_t > &buffer, uint64_t value)
	Writes a 64-bit value in big-endian byte order.
Bulk Byte Swapping for VR Types
std::vector< uint8_t >	swap_ow_bytes (std::span< const uint8_t > data)
	Swaps bytes in-place for OW (Other Word) data.
std::vector< uint8_t >	swap_ol_bytes (std::span< const uint8_t > data)
	Swaps bytes in-place for OL (Other Long) data.
std::vector< uint8_t >	swap_of_bytes (std::span< const uint8_t > data)
	Swaps bytes in-place for OF (Other Float) data.
std::vector< uint8_t >	swap_od_bytes (std::span< const uint8_t > data)
	Swaps bytes in-place for OD (Other Double) data.
std::vector< uint8_t >	swap_at_bytes (std::span< const uint8_t > data)
	Swaps bytes for AT (Attribute Tag) data.
Numeric Value Byte Swapping
std::vector< uint8_t >	swap_us_bytes (std::span< const uint8_t > data)
	Swaps bytes for US (Unsigned Short) value in raw data.
std::vector< uint8_t >	swap_ss_bytes (std::span< const uint8_t > data)
	Swaps bytes for SS (Signed Short) value in raw data.
std::vector< uint8_t >	swap_ul_bytes (std::span< const uint8_t > data)
	Swaps bytes for UL (Unsigned Long) value in raw data.
std::vector< uint8_t >	swap_sl_bytes (std::span< const uint8_t > data)
	Swaps bytes for SL (Signed Long) value in raw data.
std::vector< uint8_t >	swap_fl_bytes (std::span< const uint8_t > data)
	Swaps bytes for FL (Float) value in raw data.
std::vector< uint8_t >	swap_fd_bytes (std::span< const uint8_t > data)
	Swaps bytes for FD (Double) value in raw data.
Character Set Registry
const character_set_info *	find_character_set (std::string_view defined_term) noexcept
	Look up character set info by DICOM Defined Term.
const character_set_info *	find_character_set_by_ir (int iso_ir_number) noexcept
	Look up character set info by ISO-IR number.
const character_set_info &	default_character_set () noexcept
	Get the default character set (ISO-IR 6, ASCII).
std::vector< const character_set_info * >	all_character_sets () noexcept
	Get all registered character sets.
Specific Character Set Parsing
specific_character_set	parse_specific_character_set (std::string_view value)
	Parse a Specific Character Set (0008,0005) value.
ISO 2022 Escape Sequence Detection
std::vector< text_segment >	split_by_escape_sequences (std::string_view text, const specific_character_set &scs)
	Split a string into segments by ISO 2022 escape sequences.
String Decoding
std::string	decode_to_utf8 (std::string_view text, const specific_character_set &scs)
	Decode a DICOM string to UTF-8 using the given character set.
std::string	convert_to_utf8 (std::string_view text, const character_set_info &charset)
	Decode a single segment from a specific encoding to UTF-8.
std::string	decode_person_name (std::string_view pn_value, const specific_character_set &scs)
	Decode a Person Name (PN) value to UTF-8.
std::string	encode_from_utf8 (std::string_view utf8_text, const specific_character_set &scs)
	Encode a UTF-8 string to the target character set encoding.
std::string	convert_from_utf8 (std::string_view utf8_text, const character_set_info &charset)
	Encode a single UTF-8 segment to a specific character set.
Registry Functions
std::optional< transfer_syntax >	find_transfer_syntax (std::string_view uid)
	Looks up a Transfer Syntax by its UID.
std::vector< transfer_syntax >	supported_transfer_syntaxes ()
	Returns a list of all supported Transfer Syntaxes.
std::vector< transfer_syntax >	all_transfer_syntaxes ()
	Returns a list of all known Transfer Syntaxes.
VR Information Lookup
const vr_info &	get_vr_info (vr_type vr)
	Retrieves comprehensive metadata for a VR type.
Value Validation Functions
bool	validate_value (vr_type vr, std::span< const uint8_t > data)
	Validates binary data against VR encoding rules.
bool	validate_string (vr_type vr, std::string_view value)
	Validates a string value against VR encoding rules.
Padding Utilities
std::vector< uint8_t >	pad_to_even (vr_type vr, std::span< const uint8_t > data)
	Pads data to even length as required by DICOM.
std::string	trim_padding (vr_type vr, std::string_view value)
	Removes trailing padding characters from a string value.
Character Set Validation
bool	is_valid_charset (vr_type vr, std::string_view value)
	Validates that a string uses only allowed characters for its VR.
String Conversion Functions
constexpr std::string_view	to_string (vr_type vr) noexcept
	Converts a vr_type to its two-character string representation.
constexpr std::optional< vr_type >	from_string (std::string_view str) noexcept
	Parses a two-character string to a vr_type.
VR Category Classification Functions
constexpr bool	is_string_vr (vr_type vr) noexcept
	Checks if a VR is a string type.
constexpr bool	is_binary_vr (vr_type vr) noexcept
	Checks if a VR is a binary/raw byte type.
constexpr bool	is_numeric_vr (vr_type vr) noexcept
	Checks if a VR is a numeric type.
constexpr bool	has_explicit_32bit_length (vr_type vr) noexcept
	Checks if a VR requires 32-bit length field in Explicit VR encoding.
Additional VR Utility Functions
constexpr std::size_t	fixed_length (vr_type vr) noexcept
	Gets the fixed size of a VR if applicable.
constexpr bool	is_fixed_length (vr_type vr) noexcept
	Checks if a VR has a fixed length.
constexpr char	padding_char (vr_type vr) noexcept
	Gets the padding character for a VR.

Enumeration Type Documentation

byte_order

enum class kcenon::pacs::encoding::byte_order

strong

Byte ordering for DICOM data encoding.

DICOM supports both little-endian and big-endian byte ordering. Little-endian is the most common and is used by default in DICOM.

Enumerator
little_endian	Least significant byte first (most common)
big_endian	Most significant byte first (legacy, rarely used)

Definition at line 22 of file byte_order.h.

                      {
    little_endian,  
    big_endian      
};

vr_encoding

enum class kcenon::pacs::encoding::vr_encoding

strong

Value Representation encoding mode.

Determines whether VR (Value Representation) is explicitly encoded in the data stream or implicitly determined from the tag.

Enumerator
implicit	VR determined from data dictionary lookup.
explicit_vr	VR explicitly encoded in the data stream.

Definition at line 33 of file byte_order.h.

                       {
    implicit,    
    explicit_vr  
};

vr_type

enum class kcenon::pacs::encoding::vr_type : uint16_t

strong

DICOM Value Representation (VR) types.

Value Representation specifies the data type and format of the data element value. Each VR is encoded as two ASCII characters (e.g., "PN" for Person Name). The enum values are the uint16_t representation of these two ASCII characters.

See also

DICOM PS3.5 Section 6.2 - Value Representation (VR)

Enumerator
AE	Application Entity (16 chars max)
AS	Age String (4 chars, format: nnnD/W/M/Y)
CS	Code String (16 chars max, uppercase + digits + space + underscore)
DA	Date (8 chars, format: YYYYMMDD)
DS	Decimal String (16 chars max)
DT	Date Time (26 chars max)
IS	Integer String (12 chars max)
LO	Long String (64 chars max)
LT	Long Text (10240 chars max)
PN	Person Name (64 chars max per component group)
SH	Short String (16 chars max)
ST	Short Text (1024 chars max)
TM	Time (14 chars max, format: HHMMSS.FFFFFF)
UC	Unlimited Characters (2^32-2 max)
UI	Unique Identifier (64 chars max)
UR	Universal Resource Identifier (2^32-2 max)
UT	Unlimited Text (2^32-2 max)
FL	Floating Point Single (4 bytes)
FD	Floating Point Double (8 bytes)
SL	Signed Long (4 bytes)
SS	Signed Short (2 bytes)
UL	Unsigned Long (4 bytes)
US	Unsigned Short (2 bytes)
OB	Other Byte (variable length)
OD	Other Double (variable length)
OF	Other Float (variable length)
OL	Other Long (variable length)
OV	Other 64-bit Very Long (variable length)
OW	Other Word (variable length)
UN	Unknown (variable length)
AT	Attribute Tag (4 bytes)
SQ	Sequence of Items (undefined length)
SV	Signed 64-bit Very Long (8 bytes)
UV	Unsigned 64-bit Very Long (8 bytes)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_dataset.h, /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_element.h, /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/pool_manager.h, /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/private_tag_registry.h, and /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 29 of file vr_type.h.

                   : uint16_t {
    // String VRs
    AE = 0x4145,  
    AS = 0x4153,  
    CS = 0x4353,  
    DA = 0x4441,  
    DS = 0x4453,  
    DT = 0x4454,  
    IS = 0x4953,  
    LO = 0x4C4F,  
    LT = 0x4C54,  
    PN = 0x504E,  
    SH = 0x5348,  
    ST = 0x5354,  
    TM = 0x544D,  
    UC = 0x5543,  
    UI = 0x5549,  
    UR = 0x5552,  
    UT = 0x5554,  
 
    // Numeric VRs (binary encoded)
    FL = 0x464C,  
    FD = 0x4644,  
    SL = 0x534C,  
    SS = 0x5353,  
    UL = 0x554C,  
    US = 0x5553,  
 
    // Binary VRs (raw bytes)
    OB = 0x4F42,  
    OD = 0x4F44,  
    OF = 0x4F46,  
    OL = 0x4F4C,  
    OV = 0x4F56,  
    OW = 0x4F57,  
    UN = 0x554E,  
 
    // Special VRs
    AT = 0x4154,  
    SQ = 0x5351,  
    SV = 0x5356,  
    UV = 0x5556,  
};

Function Documentation

all_character_sets()

std::vector< const character_set_info * > kcenon::pacs::encoding::all_character_sets ( )

nodiscardnoexcept

Get all registered character sets.

Returns

Vector of pointers to all registered character_set_info entries

Definition at line 436 of file character_set.cpp.

                                                                   {
    std::vector<const character_set_info*> result;
    result.reserve(charset_registry.size() + 2);
    for (const auto& entry : charset_registry) {
        result.push_back(&entry);
    }
    result.push_back(&charset_ir_58);
    result.push_back(&charset_gb18030);
    return result;
}

all_transfer_syntaxes()

std::vector< transfer_syntax > kcenon::pacs::encoding::all_transfer_syntaxes ( )

nodiscard

Returns a list of all known Transfer Syntaxes.

Returns

Vector of all registered transfer_syntax instances

Definition at line 394 of file transfer_syntax.cpp.

                                                   {
    std::vector<transfer_syntax> result;
    result.reserve(TS_REGISTRY.size());
 
    for (const auto& entry : TS_REGISTRY) {
        result.push_back(transfer_syntax{entry.uid, entry.name, entry.endian,
                                         entry.vr, entry.encapsulated,
                                         entry.deflated, entry.supported});
    }
    return result;
}

byte_swap16()

uint16_t kcenon::pacs::encoding::byte_swap16 ( uint16_t value )

nodiscardconstexprnoexcept

Swaps bytes in a 16-bit value.

Parameters

value

The value to swap

Returns

The byte-swapped value

Example: 0x1234 -> 0x3412

Definition at line 40 of file byte_swap.h.

                                                                      {
    return static_cast<uint16_t>((value >> 8) | (value << 8));
}

byte_swap32()

uint32_t kcenon::pacs::encoding::byte_swap32 ( uint32_t value )

nodiscardconstexprnoexcept

Swaps bytes in a 32-bit value.

Parameters

value

The value to swap

Returns

The byte-swapped value

Example: 0x12345678 -> 0x78563412

Definition at line 51 of file byte_swap.h.

                                                                      {
    return ((value >> 24) & 0x000000FF) |
           ((value >> 8)  & 0x0000FF00) |
           ((value << 8)  & 0x00FF0000) |
           ((value << 24) & 0xFF000000);
}

byte_swap64()

uint64_t kcenon::pacs::encoding::byte_swap64 ( uint64_t value )

nodiscardconstexprnoexcept

Swaps bytes in a 64-bit value.

Parameters

value

The value to swap

Returns

The byte-swapped value

Example: 0x123456789ABCDEF0 -> 0xF0DEBC9A78563412

Definition at line 65 of file byte_swap.h.

                                                                      {
    return ((value >> 56) & 0x00000000000000FF) |
           ((value >> 40) & 0x000000000000FF00) |
           ((value >> 24) & 0x0000000000FF0000) |
           ((value >> 8)  & 0x00000000FF000000) |
           ((value << 8)  & 0x000000FF00000000) |
           ((value << 24) & 0x0000FF0000000000) |
           ((value << 40) & 0x00FF000000000000) |
           ((value << 56) & 0xFF00000000000000);
}

convert_from_utf8()

std::string kcenon::pacs::encoding::convert_from_utf8 ( std::string_view utf8_text, const character_set_info & charset )

nodiscard

Encode a single UTF-8 segment to a specific character set.

Parameters

utf8_text	The UTF-8 encoded source string
charset	The target character set

Returns

Encoded string in the target encoding

Definition at line 684 of file character_set.cpp.

                                       {
 
    if (utf8_text.empty()) {
        return {};
    }
 
    if (charset.encoding_name == "ASCII" ||
        charset.encoding_name == "UTF-8") {
        return std::string(utf8_text);
    }
 
    return icu_convert_from_utf8(utf8_text, charset);
}

References kcenon::pacs::encoding::character_set_info::encoding_name.

Referenced by encode_from_utf8().

Here is the caller graph for this function:

convert_to_utf8()

std::string kcenon::pacs::encoding::convert_to_utf8 ( std::string_view text, const character_set_info & charset )

nodiscard

Decode a single segment from a specific encoding to UTF-8.

Parameters

text	The raw bytes in the source encoding
charset	The character set of the source bytes

Returns

UTF-8 encoded string

Uses ICU (ucnv_convert) for encoding conversion. Falls back to raw bytes if conversion fails.

Definition at line 589 of file character_set.cpp.

                                       {
 
    if (text.empty()) {
        return {};
    }
 
    // ASCII and UTF-8 need no conversion
    if (charset.encoding_name == "ASCII" ||
        charset.encoding_name == "UTF-8") {
        return std::string(text);
    }
 
    return icu_convert_to_utf8(text, charset);
}

References kcenon::pacs::encoding::character_set_info::encoding_name.

Referenced by decode_to_utf8().

Here is the caller graph for this function:

decode_person_name()

std::string kcenon::pacs::encoding::decode_person_name ( std::string_view pn_value, const specific_character_set & scs )

nodiscard

Decode a Person Name (PN) value to UTF-8.

Parameters

pn_value	The raw PN value (may contain '=' component group separators)
scs	The Specific Character Set configuration

Returns

UTF-8 encoded Person Name string

PN values have up to three component groups separated by '=':

• Alphabetic (single-byte)
• Ideographic (multi-byte, e.g., kanji/hangul)
• Phonetic (single-byte, e.g., romaji/jamo)

Each component group is decoded independently.

Definition at line 641 of file character_set.cpp.

                                       {
 
    if (pn_value.empty()) {
        return {};
    }
 
    // Split by '=' into component groups
    // (Alphabetic=Ideographic=Phonetic)
    std::string result;
    result.reserve(pn_value.size() * 2);
 
    size_t start = 0;
    bool first = true;
 
    while (start <= pn_value.size()) {
        size_t eq_pos = pn_value.find('=', start);
        std::string_view group;
        if (eq_pos == std::string_view::npos) {
            group = pn_value.substr(start);
            start = pn_value.size() + 1;
        } else {
            group = pn_value.substr(start, eq_pos - start);
            start = eq_pos + 1;
        }
 
        if (!first) {
            result += '=';
        }
        first = false;
 
        // Decode each component group independently
        result += decode_to_utf8(group, scs);
    }
 
    return result;
}

References decode_to_utf8().

Here is the call graph for this function:

decode_to_utf8()

std::string kcenon::pacs::encoding::decode_to_utf8 ( std::string_view text, const specific_character_set & scs )

nodiscard

Decode a DICOM string to UTF-8 using the given character set.

Parameters

text	The raw DICOM string bytes
scs	The Specific Character Set configuration

Returns

UTF-8 encoded string

This is the main entry point for character set conversion. It:

1. Checks if conversion is needed (UTF-8 passthrough)
2. Splits text by escape sequences (if ISO 2022)
3. Converts each segment to UTF-8
4. Concatenates the results

If conversion fails for any segment, the raw bytes are passed through.

Definition at line 606 of file character_set.cpp.

                                       {
 
    if (text.empty()) {
        return {};
    }
 
    // Fast path: UTF-8 passthrough
    if (scs.is_utf8()) {
        return std::string(text);
    }
 
    // Fast path: single-byte charset without extensions
    if (!scs.uses_extensions()) {
        return convert_to_utf8(text, *scs.default_set);
    }
 
    // ISO 2022: split by escape sequences and convert each segment
    auto segments = split_by_escape_sequences(text, scs);
 
    std::string result;
    result.reserve(text.size() * 2);
 
    for (const auto& seg : segments) {
        if (seg.charset) {
            result += convert_to_utf8(seg.text, *seg.charset);
        } else {
            result.append(seg.text);
        }
    }
 
    return result;
}

References convert_to_utf8(), kcenon::pacs::encoding::specific_character_set::default_set, kcenon::pacs::encoding::specific_character_set::is_utf8(), split_by_escape_sequences(), and kcenon::pacs::encoding::specific_character_set::uses_extensions().

Referenced by decode_person_name(), and get_decoded_string().

Here is the call graph for this function:

Here is the caller graph for this function:

default_character_set()

const character_set_info & kcenon::pacs::encoding::default_character_set ( )

nodiscardnoexcept

Get the default character set (ISO-IR 6, ASCII).

Returns

Reference to the ASCII character set info

Definition at line 431 of file character_set.cpp.

                                                           {
    // ISO_IR 6 (ASCII) is always the first entry
    return charset_registry[0];
}

Referenced by parse_specific_character_set().

Here is the caller graph for this function:

encode_from_utf8()

std::string kcenon::pacs::encoding::encode_from_utf8 ( std::string_view utf8_text, const specific_character_set & scs )

nodiscard

Encode a UTF-8 string to the target character set encoding.

Parameters

utf8_text	The UTF-8 encoded source string
scs	The Specific Character Set configuration

Returns

Encoded string with ISO 2022 escape sequences if needed

This is the reverse of decode_to_utf8(). It converts a UTF-8 string to the encoding specified by the Specific Character Set, inserting ISO 2022 escape sequences as appropriate for CJK text.

If the charset is UTF-8, the input is returned unchanged. If conversion fails, the raw UTF-8 bytes are returned as-is.

Definition at line 700 of file character_set.cpp.

                                       {
 
    if (utf8_text.empty()) {
        return {};
    }
 
    // Fast path: UTF-8 passthrough
    if (scs.is_utf8()) {
        return std::string(utf8_text);
    }
 
    // No extensions: simple single-charset conversion
    if (!scs.uses_extensions()) {
        return convert_from_utf8(utf8_text, *scs.default_set);
    }
 
    // ISO 2022 with extensions: detect non-ASCII runs and wrap with
    // escape sequences for the first available CJK extension charset.
    // Strategy: scan UTF-8 text byte by byte. ASCII bytes (< 0x80) use
    // the default charset. Non-ASCII byte runs are converted using the
    // first multi-byte extension charset, bracketed by escape sequences.
 
    const character_set_info* mb_charset = nullptr;
    for (const auto* cs : scs.extension_sets) {
        if (cs && cs->is_multi_byte) {
            mb_charset = cs;
            break;
        }
    }
 
    if (!mb_charset) {
        // No multi-byte extension available; convert with default
        return convert_from_utf8(utf8_text, *scs.default_set);
    }
 
    std::string result;
    result.reserve(utf8_text.size() * 2);
 
    bool in_multibyte = false;
    size_t run_start = 0;
 
    for (size_t i = 0; i < utf8_text.size(); ) {
        auto uc = static_cast<unsigned char>(utf8_text[i]);
        bool is_ascii = (uc < 0x80);
 
        if (is_ascii) {
            if (in_multibyte) {
                // Flush multi-byte run
                auto mb_run = utf8_text.substr(run_start, i - run_start);
                result.append(mb_charset->escape_sequence);
                result += convert_from_utf8(mb_run, *mb_charset);
                // Return to ASCII
                result.append(esc_ir_6);
                in_multibyte = false;
            }
            if (!in_multibyte && i == run_start) {
                // Continue ASCII
            }
            run_start = i;
            result += utf8_text[i];
            ++i;
            run_start = i;
        } else {
            if (!in_multibyte) {
                in_multibyte = true;
                run_start = i;
            }
            // Skip multi-byte UTF-8 sequence
            if (uc < 0xC0) { ++i; }
            else if (uc < 0xE0) { i += 2; }
            else if (uc < 0xF0) { i += 3; }
            else { i += 4; }
            // Clamp to text size
            if (i > utf8_text.size()) { i = utf8_text.size(); }
        }
    }
 
    // Flush remaining multi-byte run
    if (in_multibyte && run_start < utf8_text.size()) {
        auto mb_run = utf8_text.substr(run_start);
        result.append(mb_charset->escape_sequence);
        result += convert_from_utf8(mb_run, *mb_charset);
        result.append(esc_ir_6);
    }
 
    return result;
}

References convert_from_utf8(), kcenon::pacs::encoding::specific_character_set::default_set, kcenon::pacs::encoding::character_set_info::escape_sequence, kcenon::pacs::encoding::specific_character_set::extension_sets, kcenon::pacs::encoding::specific_character_set::is_utf8(), and kcenon::pacs::encoding::specific_character_set::uses_extensions().

Referenced by set_encoded_string().

Here is the call graph for this function:

Here is the caller graph for this function:

find_character_set()

const character_set_info * kcenon::pacs::encoding::find_character_set ( std::string_view defined_term )

nodiscardnoexcept

Look up character set info by DICOM Defined Term.

Parameters

defined_term

The DICOM Defined Term (e.g., "ISO 2022 IR 149", "ISO_IR 100")

Returns

Pointer to character_set_info, or nullptr if not found

Supports both forms: "ISO_IR 100" (without code extensions) and "ISO 2022 IR 149" (with code extensions).

Definition at line 421 of file character_set.cpp.

                                          {
    return find_in_registry(defined_term);
}

find_character_set_by_ir()

const character_set_info * kcenon::pacs::encoding::find_character_set_by_ir ( int iso_ir_number )

nodiscardnoexcept

Look up character set info by ISO-IR number.

Parameters

iso_ir_number

The ISO-IR number (e.g., 149, 87, 100)

Returns

Pointer to character_set_info, or nullptr if not found

Definition at line 426 of file character_set.cpp.

                                {
    return find_by_ir_number(iso_ir_number);
}

find_transfer_syntax()

std::optional< transfer_syntax > kcenon::pacs::encoding::find_transfer_syntax ( std::string_view uid )

nodiscard

Looks up a Transfer Syntax by its UID.

Allow registry functions to use private constructor.

Parameters

uid	The Transfer Syntax UID to search for

Returns

The transfer_syntax if found, std::nullopt otherwise

Definition at line 371 of file transfer_syntax.cpp.

                                                                      {
    if (const auto* entry = find_entry(uid)) {
        return transfer_syntax{entry->uid, entry->name, entry->endian,
                               entry->vr, entry->encapsulated, entry->deflated,
                               entry->supported};
    }
    return std::nullopt;
}

fixed_length()

std::size_t kcenon::pacs::encoding::fixed_length ( vr_type vr )

nodiscardconstexprnoexcept

Gets the fixed size of a VR if applicable.

Parameters

vr	The VR type to check

Returns

The fixed size in bytes, or 0 if the VR has variable length

Fixed-length VRs have a predetermined size regardless of value.

Definition at line 260 of file vr_type.h.

                                                                    {
    switch (vr) {
        case vr_type::AT: return 4;  // Attribute Tag
        case vr_type::FL: return 4;  // Float
        case vr_type::FD: return 8;  // Double
        case vr_type::SL: return 4;  // Signed Long
        case vr_type::SS: return 2;  // Signed Short
        case vr_type::SV: return 8;  // Signed 64-bit
        case vr_type::UL: return 4;  // Unsigned Long
        case vr_type::US: return 2;  // Unsigned Short
        case vr_type::UV: return 8;  // Unsigned 64-bit
        default: return 0;           // Variable length
    }
}

References AT, FD, FL, SL, SS, SV, UL, US, UV, and vr.

Referenced by kcenon::pacs::core::dicom_file::decode_explicit_vr_be(), kcenon::pacs::core::dicom_file::encode_explicit_vr_be(), and is_fixed_length().

Here is the caller graph for this function:

from_string()

std::optional< vr_type > kcenon::pacs::encoding::from_string ( std::string_view str )

nodiscardconstexprnoexcept

Parses a two-character string to a vr_type.

Parameters

str	The string to parse (must be exactly 2 characters)

Returns

The corresponding vr_type, or std::nullopt if not recognized

Definition at line 132 of file vr_type.h.

                                                                                      {
    if (str.size() != 2) {
        return std::nullopt;
    }
 
    // Convert two ASCII chars to uint16_t (big-endian: first char is high byte)
    const auto code = static_cast<uint16_t>(
        (static_cast<uint16_t>(static_cast<unsigned char>(str[0])) << 8) |
        static_cast<uint16_t>(static_cast<unsigned char>(str[1]))
    );
 
    // Validate by checking if the code corresponds to a known VR
    switch (static_cast<vr_type>(code)) {
        case vr_type::AE: case vr_type::AS: case vr_type::AT:
        case vr_type::CS: case vr_type::DA: case vr_type::DS:
        case vr_type::DT: case vr_type::FD: case vr_type::FL:
        case vr_type::IS: case vr_type::LO: case vr_type::LT:
        case vr_type::OB: case vr_type::OD: case vr_type::OF:
        case vr_type::OL: case vr_type::OV: case vr_type::OW:
        case vr_type::PN: case vr_type::SH: case vr_type::SL:
        case vr_type::SQ: case vr_type::SS: case vr_type::ST:
        case vr_type::SV: case vr_type::TM: case vr_type::UC:
        case vr_type::UI: case vr_type::UL: case vr_type::UN:
        case vr_type::UR: case vr_type::US: case vr_type::UT:
        case vr_type::UV:
            return static_cast<vr_type>(code);
        default:
            return std::nullopt;
    }
}

References AE, AS, AT, code, CS, DA, DS, DT, FD, FL, IS, LO, LT, OB, OD, OF, OL, OV, OW, PN, SH, SL, SQ, SS, ST, SV, TM, UC, UI, UL, UN, UR, US, UT, and UV.

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_element(), kcenon::pacs::encoding::explicit_vr_codec::decode_element(), kcenon::pacs::core::dicom_file::decode_explicit_vr_be(), kcenon::pacs::core::dicom_file::decode_explicit_vr_le(), kcenon::pacs::core::dicom_file::decode_implicit_vr_le(), kcenon::pacs::integration::container_adapter::parse_element_key(), and kcenon::pacs::core::dicom_file::parse_meta_information().

Here is the caller graph for this function:

get_decoded_string()

std::string kcenon::pacs::encoding::get_decoded_string ( const core::dicom_dataset & ds, core::dicom_tag tag, std::string_view default_value = "" )

nodiscard

Get a string value from dataset, decoded to UTF-8.

Parameters

ds	The DICOM dataset to read from
tag	The DICOM tag to look up
default_value	Value to return if element not found

Returns

UTF-8 decoded string value, or default_value if not found

Looks up Specific Character Set (0008,0005) in the dataset and uses it to decode the raw string bytes to UTF-8. If no Specific Character Set is present, ASCII decoding is assumed (raw passthrough).

Definition at line 16 of file dataset_charset.cpp.

                                  {
 
    const auto* elem = ds.get(tag);
    if (elem == nullptr) {
        return std::string{default_value};
    }
 
    auto raw = elem->as_string();
    if (!raw.is_ok()) {
        return std::string{default_value};
    }
 
    // Look up Specific Character Set (0008,0005)
    auto scs_value = ds.get_string(core::tags::specific_character_set);
    auto scs = parse_specific_character_set(scs_value);
 
    return decode_to_utf8(raw.value(), scs);
}

References decode_to_utf8(), kcenon::pacs::core::dicom_dataset::get(), kcenon::pacs::core::dicom_dataset::get_string(), parse_specific_character_set(), and kcenon::pacs::core::tags::specific_character_set.

Here is the call graph for this function:

get_vr_info()

const vr_info & kcenon::pacs::encoding::get_vr_info ( vr_type vr )

nodiscard

Retrieves comprehensive metadata for a VR type.

Parameters

vr	The VR type to look up

Returns

Reference to vr_info structure containing VR properties

This function provides all properties needed for encoding/decoding operations, including name, maximum length, padding requirements, and fixed/variable length information.

Note

Returns info for vr_type::UN if an unknown VR is provided.

Definition at line 131 of file vr_info.cpp.

                                       {
    const auto& map = get_vr_map();
    auto it = map.find(vr);
    if (it != map.end()) {
        return *it->second;
    }
    // Return UN info for unknown VR types
    return un_info;
}

References vr.

Referenced by pad_to_even(), trim_padding(), validate_string(), and validate_value().

Here is the caller graph for this function:

has_explicit_32bit_length()

bool kcenon::pacs::encoding::has_explicit_32bit_length ( vr_type vr )

nodiscardconstexprnoexcept

Checks if a VR requires 32-bit length field in Explicit VR encoding.

Parameters

vr	The VR type to check

Returns

true if the VR requires extended 32-bit length encoding

In Explicit VR encoding, these VRs have a 2-byte reserved field followed by a 4-byte length field, instead of a 2-byte length field.

See also

DICOM PS3.5 Section 7.1.2 - Data Element Structure with Explicit VR

Definition at line 235 of file vr_type.h.

                                                                            {
    switch (vr) {
        case vr_type::OB: case vr_type::OD: case vr_type::OF:
        case vr_type::OL: case vr_type::OV: case vr_type::OW:
        case vr_type::SQ: case vr_type::SV: case vr_type::UC:
        case vr_type::UN: case vr_type::UR: case vr_type::UT:
        case vr_type::UV:
            return true;
        default:
            return false;
    }
}

References OB, OD, OF, OL, OV, OW, SQ, SV, UC, UN, UR, UT, UV, and vr.

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_element(), kcenon::pacs::encoding::explicit_vr_codec::decode_element(), kcenon::pacs::core::dicom_file::decode_explicit_vr_be(), kcenon::pacs::core::dicom_file::decode_explicit_vr_le(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_element(), kcenon::pacs::encoding::explicit_vr_codec::encode_element(), kcenon::pacs::core::dicom_file::encode_explicit_vr_be(), kcenon::pacs::core::dicom_file::encode_explicit_vr_le(), and kcenon::pacs::core::dicom_file::parse_meta_information().

Here is the caller graph for this function:

is_binary_vr()

bool kcenon::pacs::encoding::is_binary_vr ( vr_type vr )

nodiscardconstexprnoexcept

Checks if a VR is a binary/raw byte type.

Parameters

vr	The VR type to check

Returns

true if the VR represents raw binary data

Binary VRs include OB, OD, OF, OL, OV, OW, and UN.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 196 of file vr_type.h.

                                                               {
    switch (vr) {
        case vr_type::OB: case vr_type::OD: case vr_type::OF:
        case vr_type::OL: case vr_type::OV: case vr_type::OW:
        case vr_type::UN:
            return true;
        default:
            return false;
    }
}

References OB, OD, OF, OL, OV, OW, UN, and vr.

Referenced by kcenon::pacs::integration::container_adapter::maps_to_binary(), and kcenon::pacs::integration::container_adapter::to_container_value().

Here is the caller graph for this function:

is_fixed_length()

bool kcenon::pacs::encoding::is_fixed_length ( vr_type vr )

nodiscardconstexprnoexcept

Checks if a VR has a fixed length.

Parameters

vr	The VR type to check

Returns

true if the VR has a fixed length

Definition at line 280 of file vr_type.h.

                                                                  {
    return fixed_length(vr) > 0;
}

References fixed_length(), and vr.

Here is the call graph for this function:

is_numeric_vr()

bool kcenon::pacs::encoding::is_numeric_vr ( vr_type vr )

nodiscardconstexprnoexcept

Checks if a VR is a numeric type.

Parameters

vr	The VR type to check

Returns

true if the VR represents numeric data (binary encoded)

Numeric VRs include FL, FD, SL, SS, SV, UL, US, UV.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 214 of file vr_type.h.

                                                                {
    switch (vr) {
        case vr_type::FL: case vr_type::FD:
        case vr_type::SL: case vr_type::SS: case vr_type::SV:
        case vr_type::UL: case vr_type::US: case vr_type::UV:
            return true;
        default:
            return false;
    }
}

References FD, FL, SL, SS, SV, UL, US, UV, and vr.

Referenced by kcenon::pacs::core::dicom_element::as_string(), kcenon::pacs::core::dicom_file::decode_explicit_vr_be(), kcenon::pacs::core::dicom_file::encode_explicit_vr_be(), kcenon::pacs::integration::container_adapter::from_container_value(), kcenon::pacs::integration::container_adapter::maps_to_numeric(), and kcenon::pacs::integration::container_adapter::to_container_value().

Here is the caller graph for this function:

is_string_vr()

bool kcenon::pacs::encoding::is_string_vr ( vr_type vr )

nodiscardconstexprnoexcept

Checks if a VR is a string type.

Parameters

vr	The VR type to check

Returns

true if the VR represents string/text data

String VRs contain character data that may need padding with spaces.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 175 of file vr_type.h.

                                                               {
    switch (vr) {
        case vr_type::AE: case vr_type::AS: case vr_type::CS:
        case vr_type::DA: case vr_type::DS: case vr_type::DT:
        case vr_type::IS: case vr_type::LO: case vr_type::LT:
        case vr_type::PN: case vr_type::SH: case vr_type::ST:
        case vr_type::TM: case vr_type::UC: case vr_type::UI:
        case vr_type::UR: case vr_type::UT:
            return true;
        default:
            return false;
    }
}

References AE, AS, CS, DA, DS, DT, IS, LO, LT, PN, SH, ST, TM, UC, UI, UR, UT, and vr.

Referenced by kcenon::pacs::core::dicom_element::as_string(), kcenon::pacs::integration::container_adapter::from_container_value(), kcenon::pacs::integration::container_adapter::get_container_type(), kcenon::pacs::integration::container_adapter::maps_to_string(), padding_char(), kcenon::pacs::core::dicom_element::remove_padding(), kcenon::pacs::integration::container_adapter::to_container_value(), validate_string(), and validate_value().

Here is the caller graph for this function:

is_valid_charset()

bool kcenon::pacs::encoding::is_valid_charset ( vr_type vr, std::string_view value )

nodiscard

Validates that a string uses only allowed characters for its VR.

Parameters

vr	The VR type
value	The string to validate

Returns

true if all characters are valid for the VR

Character restrictions by VR type:

• CS: A-Z, 0-9, space, underscore
• DA: 0-9 only (YYYYMMDD format)
• TM: 0-9, period, colon
• UI: 0-9, period
• DS: 0-9, +, -, ., E, e, space
• IS: 0-9, +, -
• AS: 0-9, D, W, M, Y
• Other string VRs: All printable characters

Definition at line 225 of file vr_info.cpp.

                                                        {
    switch (vr) {
        case vr_type::CS:
            // Code String: A-Z, 0-9, space, underscore
            return std::all_of(value.begin(), value.end(), is_cs_char);
 
        case vr_type::DA:
            // Date: YYYYMMDD format, digits only
            return value.size() == 8 &&
                   std::all_of(value.begin(), value.end(), is_da_char);
 
        case vr_type::TM:
            // Time: digits, period, colon
            return std::all_of(value.begin(), value.end(), is_tm_char);
 
        case vr_type::UI:
            // UID: digits and periods only, max 64 chars
            return value.size() <= 64 &&
                   std::all_of(value.begin(), value.end(), is_ui_char);
 
        case vr_type::DS:
            // Decimal String: digits, +, -, ., E, e, space
            return std::all_of(value.begin(), value.end(), is_ds_char);
 
        case vr_type::IS:
            // Integer String: digits, +, -
            return std::all_of(value.begin(), value.end(), is_is_char);
 
        case vr_type::AS:
            // Age String: nnnX format where X is D/W/M/Y
            if (value.size() != 4) {
                return false;
            }
            return std::all_of(value.begin(), value.end(), is_as_char) &&
                   (value[3] == 'D' || value[3] == 'W' ||
                    value[3] == 'M' || value[3] == 'Y');
 
        case vr_type::DT:
            // Date Time: digits, period, +, -
            return std::all_of(value.begin(), value.end(), is_dt_char);
 
        case vr_type::AE:
        case vr_type::LO:
        case vr_type::SH:
        case vr_type::PN:
            // These allow most printable characters but no control chars
            // except leading/trailing spaces
            return std::all_of(value.begin(), value.end(), is_printable);
 
        case vr_type::LT:
        case vr_type::ST:
        case vr_type::UT:
        case vr_type::UC:
        case vr_type::UR:
            // Text VRs allow all printable plus CR, LF, FF, TAB
            return std::all_of(value.begin(), value.end(), is_printable);
 
        default:
            // Non-string VRs - charset validation not applicable
            return true;
    }
}

References AE, AS, CS, DA, DS, DT, IS, LO, LT, PN, SH, ST, TM, UC, UI, UR, UT, and vr.

Referenced by validate_string(), and validate_value().

Here is the caller graph for this function:

pad_to_even()

std::vector< uint8_t > kcenon::pacs::encoding::pad_to_even ( vr_type vr, std::span< const uint8_t > data )

nodiscard

Pads data to even length as required by DICOM.

Parameters

vr	The VR type (determines padding character)
data	The data to pad

Returns

A new vector with even-length data

DICOM requires all data element values to have even length. This function adds the appropriate padding character if needed:

• Space (' ') for most string VRs
• Null ('\0') for UI and binary VRs

See also

DICOM PS3.5 Section 7.1.1 - DICOM Data Element Structure

Definition at line 196 of file vr_info.cpp.

                                                                        {
    std::vector<uint8_t> result(data.begin(), data.end());
 
    if (result.size() % 2 != 0) {
        const auto& info = get_vr_info(vr);
        result.push_back(static_cast<uint8_t>(info.padding_char));
    }
 
    return result;
}

References get_vr_info(), and vr.

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_element(), kcenon::pacs::encoding::explicit_vr_codec::encode_element(), and kcenon::pacs::encoding::implicit_vr_codec::encode_element().

Here is the call graph for this function:

Here is the caller graph for this function:

padding_char()

char kcenon::pacs::encoding::padding_char ( vr_type vr )

nodiscardconstexprnoexcept

Gets the padding character for a VR.

Parameters

vr	The VR type to check

Returns

The padding character (' ' for most strings, '\0' for UI, 0 for binary)

DICOM requires data elements to have even length. String VRs are padded with space (' ') except for UI which is padded with null ('\0').

Definition at line 292 of file vr_type.h.

                                                               {
    if (vr == vr_type::UI) {
        return '\0';  // UI uses null padding
    }
    if (is_string_vr(vr)) {
        return ' ';   // Other string VRs use space padding
    }
    return '\0';      // Binary VRs use null padding if needed
}

References is_string_vr(), UI, and vr.

Referenced by kcenon::pacs::core::dicom_element::apply_padding(), and kcenon::pacs::core::dicom_element::remove_padding().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_specific_character_set()

specific_character_set kcenon::pacs::encoding::parse_specific_character_set ( std::string_view value )

nodiscard

Parse a Specific Character Set (0008,0005) value.

Parameters

value

The raw attribute value (e.g., "\\ISO 2022 IR 149")

Returns

Parsed specific_character_set with resolved character set pointers

Handles multi-valued strings separated by backslash ('\'). Empty first component defaults to ISO-IR 6 (ASCII). Unknown Defined Terms are skipped with a warning.

Definition at line 471 of file character_set.cpp.

                                                                          {
    specific_character_set result;
    result.default_set = &default_character_set();
 
    if (value.empty()) {
        return result;
    }
 
    // Split by backslash
    std::vector<std::string_view> components;
    size_t start = 0;
    while (start <= value.size()) {
        size_t pos = value.find('\\', start);
        if (pos == std::string_view::npos) {
            components.push_back(value.substr(start));
            break;
        }
        components.push_back(value.substr(start, pos - start));
        start = pos + 1;
    }
 
    if (components.empty()) {
        return result;
    }
 
    // First component: default character set
    auto first = components[0];
    // Trim whitespace
    while (!first.empty() && first.front() == ' ') first.remove_prefix(1);
    while (!first.empty() && first.back() == ' ') first.remove_suffix(1);
 
    if (!first.empty()) {
        const auto* cs = find_in_registry(first);
        if (cs) {
            result.default_set = cs;
        }
    }
    // Empty first component: ASCII default (already set)
 
    // Remaining components: extension character sets
    for (size_t i = 1; i < components.size(); ++i) {
        auto term = components[i];
        while (!term.empty() && term.front() == ' ') term.remove_prefix(1);
        while (!term.empty() && term.back() == ' ') term.remove_suffix(1);
 
        if (!term.empty()) {
            const auto* cs = find_in_registry(term);
            if (cs) {
                result.extension_sets.push_back(cs);
            }
        }
    }
 
    return result;
}

References default_character_set(), kcenon::pacs::encoding::specific_character_set::default_set, and kcenon::pacs::encoding::specific_character_set::extension_sets.

Referenced by get_decoded_string(), and set_encoded_string().

Here is the call graph for this function:

Here is the caller graph for this function:

read_be16()

uint16_t kcenon::pacs::encoding::read_be16 ( const uint8_t * data )

nodiscardconstexprnoexcept

Reads a 16-bit value from big-endian bytes.

Parameters

data	Pointer to at least 2 bytes

Returns

The value in native byte order

Definition at line 86 of file byte_swap.h.

                                                                         {
    return (static_cast<uint16_t>(data[0]) << 8) |
           static_cast<uint16_t>(data[1]);
}

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_element(), kcenon::pacs::encoding::compression::jpeg_lossless_codec::impl::decode_frame(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_sequence_item(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_undefined_length().

Here is the caller graph for this function:

read_be32()

uint32_t kcenon::pacs::encoding::read_be32 ( const uint8_t * data )

nodiscardconstexprnoexcept

Reads a 32-bit value from big-endian bytes.

Parameters

data	Pointer to at least 4 bytes

Returns

The value in native byte order

Definition at line 96 of file byte_swap.h.

                                                                         {
    return (static_cast<uint32_t>(data[0]) << 24) |
           (static_cast<uint32_t>(data[1]) << 16) |
           (static_cast<uint32_t>(data[2]) << 8) |
           static_cast<uint32_t>(data[3]);
}

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_element(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_sequence_item(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode_undefined_length().

Here is the caller graph for this function:

read_be64()

uint64_t kcenon::pacs::encoding::read_be64 ( const uint8_t * data )

nodiscardconstexprnoexcept

Reads a 64-bit value from big-endian bytes.

Parameters

data	Pointer to at least 8 bytes

Returns

The value in native byte order

Definition at line 108 of file byte_swap.h.

                                                                         {
    return (static_cast<uint64_t>(data[0]) << 56) |
           (static_cast<uint64_t>(data[1]) << 48) |
           (static_cast<uint64_t>(data[2]) << 40) |
           (static_cast<uint64_t>(data[3]) << 32) |
           (static_cast<uint64_t>(data[4]) << 24) |
           (static_cast<uint64_t>(data[5]) << 16) |
           (static_cast<uint64_t>(data[6]) << 8) |
           static_cast<uint64_t>(data[7]);
}

set_encoded_string()

void kcenon::pacs::encoding::set_encoded_string	(	core::dicom_dataset &	ds,
		core::dicom_tag	tag,
		vr_type	vr,
		std::string_view	utf8_value )

Set a string value in dataset, encoding from UTF-8.

Parameters

ds	The DICOM dataset to write to
tag	The DICOM tag
vr	The value representation
utf8_value	The UTF-8 encoded string value

Encodes the UTF-8 input to the encoding specified by Specific Character Set (0008,0005) in the dataset, then stores the result. If no Specific Character Set is present, the value is stored as-is (ASCII assumption).

Definition at line 38 of file dataset_charset.cpp.

                               {
 
    // Look up Specific Character Set (0008,0005)
    auto scs_value = ds.get_string(core::tags::specific_character_set);
    auto scs = parse_specific_character_set(scs_value);
 
    auto encoded = encode_from_utf8(utf8_value, scs);
    ds.insert(core::dicom_element::from_string(tag, vr, encoded));
}

References encode_from_utf8(), kcenon::pacs::core::dicom_element::from_string(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::dicom_dataset::insert(), parse_specific_character_set(), kcenon::pacs::core::tags::specific_character_set, and vr.

Here is the call graph for this function:

split_by_escape_sequences()

std::vector< text_segment > kcenon::pacs::encoding::split_by_escape_sequences ( std::string_view text, const specific_character_set & scs )

nodiscard

Split a string into segments by ISO 2022 escape sequences.

Parameters

text	The raw DICOM string bytes
scs	The parsed Specific Character Set configuration

Returns

Vector of text segments, each with its character set

Scans for ESC (0x1B) bytes, matches escape sequences against the configured character sets, and splits the text into segments. Segments between escape sequences inherit the previous character set.

Definition at line 531 of file character_set.cpp.

                                       {
 
    std::vector<text_segment> segments;
 
    if (text.empty()) {
        return segments;
    }
 
    // If no extensions, the entire text uses the default charset
    if (!scs.uses_extensions()) {
        segments.push_back({text, scs.default_set});
        return segments;
    }
 
    const character_set_info* current_charset = scs.default_set;
    size_t segment_start = 0;
 
    for (size_t i = 0; i < text.size(); ++i) {
        if (text[i] == ESC) {
            // Try to match an escape sequence
            const auto* new_charset = find_by_escape_sequence(text, i, scs);
            if (new_charset) {
                // Emit the segment before this escape sequence
                if (i > segment_start) {
                    segments.push_back({
                        text.substr(segment_start, i - segment_start),
                        current_charset
                    });
                }
 
                // Skip the escape sequence
                size_t esc_len = new_charset->escape_sequence.empty()
                    ? esc_ir_6.size()  // ASCII return
                    : new_charset->escape_sequence.size();
                i += esc_len - 1;  // -1 because loop increments
                segment_start = i + 1;
                current_charset = new_charset;
            }
        }
    }
 
    // Emit the remaining segment
    if (segment_start < text.size()) {
        segments.push_back({
            text.substr(segment_start),
            current_charset
        });
    }
 
    return segments;
}

References kcenon::pacs::encoding::specific_character_set::default_set, and kcenon::pacs::encoding::specific_character_set::uses_extensions().

Referenced by decode_to_utf8().

Here is the call graph for this function:

Here is the caller graph for this function:

supported_transfer_syntaxes()

std::vector< transfer_syntax > kcenon::pacs::encoding::supported_transfer_syntaxes ( )

nodiscard

Returns a list of all supported Transfer Syntaxes.

Returns

Vector of supported transfer_syntax instances

Definition at line 380 of file transfer_syntax.cpp.

                                                         {
    std::vector<transfer_syntax> result;
    result.reserve(TS_REGISTRY.size());
 
    for (const auto& entry : TS_REGISTRY) {
        if (entry.supported) {
            result.push_back(transfer_syntax{entry.uid, entry.name, entry.endian,
                                             entry.vr, entry.encapsulated,
                                             entry.deflated, entry.supported});
        }
    }
    return result;
}

swap_at_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_at_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for AT (Attribute Tag) data.

Parameters

data	Span of bytes (must be multiple of 4)

Returns

Byte-swapped copy of the data

AT consists of two 16-bit values (group, element), each needing byte swap.

Definition at line 226 of file byte_swap.h.

                                 {
    return swap_ow_bytes(data);  // Each 16-bit part swapped individually
}

References swap_ow_bytes().

Here is the call graph for this function:

swap_fd_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_fd_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for FD (Double) value in raw data.

Parameters

data	Span of 8 bytes

Returns

Byte-swapped copy

Definition at line 291 of file byte_swap.h.

                                 {
    return swap_od_bytes(data);
}

References swap_od_bytes().

Here is the call graph for this function:

swap_fl_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_fl_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for FL (Float) value in raw data.

Parameters

data	Span of 4 bytes

Returns

Byte-swapped copy

Definition at line 281 of file byte_swap.h.

                                 {
    return swap_ol_bytes(data);
}

References swap_ol_bytes().

Here is the call graph for this function:

swap_od_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_od_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes in-place for OD (Other Double) data.

Parameters

data	Span of bytes (must be multiple of 8)

Returns

Byte-swapped copy of the data

OD data consists of 64-bit doubles that need individual byte swapping. Uses SIMD optimization (SSE/AVX/NEON) when available.

Definition at line 212 of file byte_swap.h.

                                 {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_64_simd(data.data(), result.data(), data.size());
    return result;
}

References kcenon::pacs::encoding::simd::swap_bytes_64_simd().

Referenced by swap_fd_bytes(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::to_big_endian().

Here is the call graph for this function:

Here is the caller graph for this function:

swap_of_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_of_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes in-place for OF (Other Float) data.

Parameters

data	Span of bytes (must be multiple of 4)

Returns

Byte-swapped copy of the data

OF data consists of 32-bit floats that need individual byte swapping.

Definition at line 199 of file byte_swap.h.

                                 {
    return swap_ol_bytes(data);  // Same as OL (32-bit values)
}

References swap_ol_bytes().

Here is the call graph for this function:

swap_ol_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_ol_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes in-place for OL (Other Long) data.

Parameters

data	Span of bytes (must be multiple of 4)

Returns

Byte-swapped copy of the data

OL data consists of 32-bit values that need individual byte swapping. Uses SIMD optimization (SSE/AVX/NEON) when available.

Definition at line 185 of file byte_swap.h.

                                 {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_32_simd(data.data(), result.data(), data.size());
    return result;
}

References kcenon::pacs::encoding::simd::swap_bytes_32_simd().

Referenced by swap_fl_bytes(), swap_of_bytes(), swap_sl_bytes(), swap_ul_bytes(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::to_big_endian().

Here is the call graph for this function:

Here is the caller graph for this function:

swap_ow_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_ow_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes in-place for OW (Other Word) data.

Parameters

data	Span of bytes (must be even length)

Returns

Byte-swapped copy of the data

OW data consists of 16-bit words that need individual byte swapping. Uses SIMD optimization (SSE/AVX/NEON) when available.

Definition at line 170 of file byte_swap.h.

                                 {
    std::vector<uint8_t> result(data.size());
    simd::swap_bytes_16_simd(data.data(), result.data(), data.size());
    return result;
}

References kcenon::pacs::encoding::simd::swap_bytes_16_simd().

Referenced by swap_at_bytes(), swap_ss_bytes(), swap_us_bytes(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::to_big_endian().

Here is the call graph for this function:

Here is the caller graph for this function:

swap_sl_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_sl_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for SL (Signed Long) value in raw data.

Parameters

data	Span of 4 bytes

Returns

Byte-swapped copy

Definition at line 271 of file byte_swap.h.

                                 {
    return swap_ol_bytes(data);
}

References swap_ol_bytes().

Here is the call graph for this function:

swap_ss_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_ss_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for SS (Signed Short) value in raw data.

Parameters

data	Span of 2 bytes

Returns

Byte-swapped copy

Definition at line 251 of file byte_swap.h.

                                 {
    return swap_ow_bytes(data);
}

References swap_ow_bytes().

Here is the call graph for this function:

swap_ul_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_ul_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for UL (Unsigned Long) value in raw data.

Parameters

data	Span of 4 bytes

Returns

Byte-swapped copy

Definition at line 261 of file byte_swap.h.

                                 {
    return swap_ol_bytes(data);
}

References swap_ol_bytes().

Here is the call graph for this function:

swap_us_bytes()

std::vector< uint8_t > kcenon::pacs::encoding::swap_us_bytes ( std::span< const uint8_t > data )

inlinenodiscard

Swaps bytes for US (Unsigned Short) value in raw data.

Parameters

data	Span of 2 bytes

Returns

Byte-swapped copy

Definition at line 241 of file byte_swap.h.

                                 {
    return swap_ow_bytes(data);
}

References swap_ow_bytes().

Here is the call graph for this function:

to_string()

std::string_view kcenon::pacs::encoding::to_string ( vr_type vr )

nodiscardconstexprnoexcept

Converts a vr_type to its two-character string representation.

Parameters

vr	The VR type to convert

Returns

A string_view containing the VR code (e.g., "PN", "US")

Returns "??" for unknown or invalid VR types.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/pir/patient_reconciliation_service.h.

Definition at line 83 of file vr_type.h.

                                                                      {
    switch (vr) {
        // String VRs
        case vr_type::AE: return "AE";
        case vr_type::AS: return "AS";
        case vr_type::CS: return "CS";
        case vr_type::DA: return "DA";
        case vr_type::DS: return "DS";
        case vr_type::DT: return "DT";
        case vr_type::IS: return "IS";
        case vr_type::LO: return "LO";
        case vr_type::LT: return "LT";
        case vr_type::PN: return "PN";
        case vr_type::SH: return "SH";
        case vr_type::ST: return "ST";
        case vr_type::TM: return "TM";
        case vr_type::UC: return "UC";
        case vr_type::UI: return "UI";
        case vr_type::UR: return "UR";
        case vr_type::UT: return "UT";
        // Numeric VRs
        case vr_type::FL: return "FL";
        case vr_type::FD: return "FD";
        case vr_type::SL: return "SL";
        case vr_type::SS: return "SS";
        case vr_type::UL: return "UL";
        case vr_type::US: return "US";
        // Binary VRs
        case vr_type::OB: return "OB";
        case vr_type::OD: return "OD";
        case vr_type::OF: return "OF";
        case vr_type::OL: return "OL";
        case vr_type::OV: return "OV";
        case vr_type::OW: return "OW";
        case vr_type::UN: return "UN";
        // Special VRs
        case vr_type::AT: return "AT";
        case vr_type::SQ: return "SQ";
        case vr_type::SV: return "SV";
        case vr_type::UV: return "UV";
        default: return "??";
    }
}

References AE, AS, AT, CS, DA, DS, DT, FD, FL, IS, LO, LT, OB, OD, OF, OL, OV, OW, PN, SH, SL, SQ, SS, ST, SV, TM, UC, UI, UL, UN, UR, US, UT, UV, and vr.

Referenced by kcenon::pacs::core::dicom_file::decode_implicit_vr_le(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_element(), kcenon::pacs::encoding::explicit_vr_codec::encode_element(), kcenon::pacs::core::dicom_file::encode_explicit_vr_be(), kcenon::pacs::core::dicom_file::encode_explicit_vr_le(), and kcenon::pacs::integration::container_adapter::make_element_key().

Here is the caller graph for this function:

trim_padding()

std::string kcenon::pacs::encoding::trim_padding ( vr_type vr, std::string_view value )

nodiscard

Removes trailing padding characters from a string value.

Parameters

vr	The VR type (determines padding character to remove)
value	The value to trim

Returns

A string with trailing padding removed

Removes:

• Trailing spaces for most string VRs
• Trailing nulls for UI VR

Definition at line 207 of file vr_info.cpp.

                                                         {
    if (value.empty()) {
        return std::string{};
    }
 
    const auto& info = get_vr_info(vr);
    char pad = info.padding_char;
 
    // Find the last non-padding character
    auto end = value.find_last_not_of(pad);
    if (end == std::string_view::npos) {
        // All characters are padding
        return std::string{};
    }
 
    return std::string{value.substr(0, end + 1)};
}

References get_vr_info(), and vr.

Here is the call graph for this function:

validate_string()

bool kcenon::pacs::encoding::validate_string ( vr_type vr, std::string_view value )

nodiscard

Validates a string value against VR encoding rules.

Parameters

vr	The VR type for validation
value	The string value to validate

Returns

true if the string conforms to VR requirements

Validates string VRs for:

• Maximum length
• Allowed character sets
• Format patterns (dates, times, UIDs, etc.)

Definition at line 170 of file vr_info.cpp.

                                                       {
    const auto& info = get_vr_info(vr);
 
    // Non-string VRs cannot be validated as strings
    if (!is_string_vr(vr)) {
        return false;
    }
 
    // Check maximum length
    if (info.max_length != 0xFFFFFFFE) {
        if (value.size() > info.max_length) {
            return false;
        }
    }
 
    // Fixed-length string VRs (AS, DA) must match exact length
    if (info.is_fixed_length && info.fixed_size > 0) {
        if (value.size() != info.fixed_size) {
            return false;
        }
    }
 
    // Validate character set
    return is_valid_charset(vr, value);
}

References get_vr_info(), is_string_vr(), is_valid_charset(), and vr.

Here is the call graph for this function:

validate_value()

bool kcenon::pacs::encoding::validate_value ( vr_type vr, std::span< const uint8_t > data )

nodiscard

Validates binary data against VR encoding rules.

Parameters

vr	The VR type for validation
data	The binary data to validate

Returns

true if the data conforms to VR requirements

Performs VR-specific validation including:

• Length constraints
• Character set restrictions
• Format requirements (for structured VRs like DA, TM)

Definition at line 141 of file vr_info.cpp.

                                                             {
    const auto& info = get_vr_info(vr);
 
    // For fixed-length VRs, check that size is a multiple of fixed_size (VM >= 1)
    if (info.is_fixed_length && info.fixed_size > 0) {
        if (data.size() % info.fixed_size != 0) {
            return false;
        }
        // Fixed-length VRs pass validation if size is correct multiple
        return true;
    }
 
    // Check maximum length for variable-length VRs (0xFFFFFFFE means unlimited)
    if (info.max_length != 0xFFFFFFFE && info.max_length != 0xFFFFFFFF) {
        if (data.size() > info.max_length) {
            return false;
        }
    }
 
    // String VRs need character validation
    if (is_string_vr(vr)) {
        std::string_view str_value(reinterpret_cast<const char*>(data.data()),
                                   data.size());
        return is_valid_charset(vr, str_value);
    }
 
    return true;
}

References get_vr_info(), is_string_vr(), is_valid_charset(), and vr.

Here is the call graph for this function:

write_be16()

void kcenon::pacs::encoding::write_be16 ( std::vector< uint8_t > & buffer, uint16_t value )

inline

Writes a 16-bit value in big-endian byte order.

Parameters

buffer	Buffer to append to
value	The value to write

Definition at line 124 of file byte_swap.h.

                                                                   {
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_element(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_sequence(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_sequence_item(), kcenon::pacs::encoding::compression::jpeg_lossless_codec::impl::write_dht(), kcenon::pacs::encoding::compression::jpeg_lossless_codec::impl::write_sof3(), and kcenon::pacs::encoding::compression::jpeg_lossless_codec::impl::write_sos().

Here is the caller graph for this function:

write_be32()

void kcenon::pacs::encoding::write_be32 ( std::vector< uint8_t > & buffer, uint32_t value )

inline

Writes a 32-bit value in big-endian byte order.

Parameters

buffer	Buffer to append to
value	The value to write

Definition at line 134 of file byte_swap.h.

                                                                   {
    buffer.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}

Referenced by kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_element(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_sequence(), and kcenon::pacs::encoding::explicit_vr_big_endian_codec::encode_sequence_item().

Here is the caller graph for this function:

write_be64()

void kcenon::pacs::encoding::write_be64 ( std::vector< uint8_t > & buffer, uint64_t value )

inline

Writes a 64-bit value in big-endian byte order.

Parameters

buffer	Buffer to append to
value	The value to write

Definition at line 146 of file byte_swap.h.

                                                                   {
    buffer.push_back(static_cast<uint8_t>((value >> 56) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 48) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 40) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 32) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
}