kcenon::pacs::core::dicom_file Class Reference

#include <dicom_file.h>

Collaboration diagram for kcenon::pacs::core::dicom_file:

Public Member Functions
auto	save (const std::filesystem::path &path) const -> kcenon::pacs::VoidResult
	Save the DICOM file to disk.
auto	to_bytes () const -> std::vector< uint8_t >
	Encode the DICOM file to raw bytes.
auto	meta_information () const noexcept -> const dicom_dataset &
	Get read-only access to the File Meta Information.
auto	meta_information () noexcept -> dicom_dataset &
	Get mutable access to the File Meta Information.
auto	dataset () const noexcept -> const dicom_dataset &
	Get read-only access to the main dataset.
auto	dataset () noexcept -> dicom_dataset &
	Get mutable access to the main dataset.
auto	transfer_syntax () const -> encoding::transfer_syntax
	Get the Transfer Syntax of this file.
auto	sop_class_uid () const -> std::string
	Get the SOP Class UID.
auto	sop_instance_uid () const -> std::string
	Get the SOP Instance UID.
	dicom_file ()=default
	Default constructor - creates an empty file.
	dicom_file (const dicom_file &)=default
	Copy constructor.
	dicom_file (dicom_file &&) noexcept=default
	Move constructor.
auto	operator= (const dicom_file &) -> dicom_file &=default
	Copy assignment.
auto	operator= (dicom_file &&) noexcept -> dicom_file &=default
	Move assignment.
	~dicom_file ()=default
	Destructor.

Static Public Member Functions
static auto	open (const std::filesystem::path &path) -> kcenon::pacs::Result< dicom_file >
	Open and read a DICOM file from disk.
static auto	from_bytes (std::span< const uint8_t > data) -> kcenon::pacs::Result< dicom_file >
	Parse a DICOM file from raw bytes.
static auto	create (dicom_dataset dataset, const encoding::transfer_syntax &ts) -> dicom_file
	Create a new DICOM file from a dataset.

Private Member Functions
	dicom_file (dicom_dataset meta_info, dicom_dataset main_dataset)
	Private constructor for internal use.

Static Private Member Functions
static auto	parse_meta_information (std::span< const uint8_t > data, size_t &bytes_read) -> kcenon::pacs::Result< dicom_dataset >
	Parse file meta information from raw data.
static auto	generate_meta_information (const dicom_dataset &dataset, const encoding::transfer_syntax &ts) -> dicom_dataset
	Generate File Meta Information for a dataset.
static auto	encode_explicit_vr_le (const dicom_dataset &dataset) -> std::vector< uint8_t >
	Encode a dataset using Explicit VR Little Endian.
static auto	decode_explicit_vr_le (std::span< const uint8_t > data, size_t &bytes_read) -> kcenon::pacs::Result< dicom_dataset >
	Decode a dataset from Explicit VR Little Endian format.
static auto	decode_implicit_vr_le (std::span< const uint8_t > data, size_t &bytes_read) -> kcenon::pacs::Result< dicom_dataset >
	Decode a dataset from Implicit VR Little Endian format.
static auto	decode_explicit_vr_be (std::span< const uint8_t > data, size_t &bytes_read) -> kcenon::pacs::Result< dicom_dataset >
	Decode a dataset from Explicit VR Big Endian format.
static auto	encode_implicit_vr_le (const dicom_dataset &dataset) -> std::vector< uint8_t >
	Encode a dataset using Implicit VR Little Endian.
static auto	encode_explicit_vr_be (const dicom_dataset &dataset) -> std::vector< uint8_t >
	Encode a dataset using Explicit VR Big Endian.
static auto	decode_dataset (std::span< const uint8_t > data, const encoding::transfer_syntax &ts, size_t &bytes_read) -> kcenon::pacs::Result< dicom_dataset >
	Decode a dataset based on its Transfer Syntax.
static auto	encode_dataset (const dicom_dataset &dataset, const encoding::transfer_syntax &ts) -> std::vector< uint8_t >
	Encode a dataset based on its Transfer Syntax.
static auto	parse_undefined_length_sequence (std::span< const uint8_t > data, size_t &bytes_read, bool explicit_vr, bool big_endian) -> kcenon::pacs::Result< std::vector< dicom_dataset > >
	Parse a sequence with undefined length.
static auto	parse_encapsulated_frames (std::span< const uint8_t > data) -> std::vector< std::vector< uint8_t > >
	Parse encapsulated pixel data frames.

Private Attributes
dicom_dataset	meta_info_
	File Meta Information (Group 0002)
dicom_dataset	dataset_
	Main dataset (encoded per Transfer Syntax)

Static Private Attributes
static constexpr std::string_view	kImplementationClassUid
	Implementation Class UID for this library.
static constexpr std::string_view	kImplementationVersionName = "PACS_SYS_001"
	Implementation Version Name.
static constexpr uint8_t	kDicmPrefix [4] = {'D', 'I', 'C', 'M'}
	DICOM magic bytes.
static constexpr size_t	kPreambleSize = 128
	Preamble size.

Detailed Description

Examples

module_example/main.cpp.

Definition at line 67 of file dicom_file.h.

Constructor & Destructor Documentation

dicom_file() [1/4]

kcenon::pacs::core::dicom_file::dicom_file ( )

default

Default constructor - creates an empty file.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

dicom_file() [2/4]

kcenon::pacs::core::dicom_file::dicom_file ( const dicom_file & )

default

Copy constructor.

dicom_file() [3/4]

kcenon::pacs::core::dicom_file::dicom_file ( dicom_file && )

defaultnoexcept

Move constructor.

~dicom_file()

kcenon::pacs::core::dicom_file::~dicom_file ( )

default

Destructor.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

dicom_file() [4/4]

kcenon::pacs::core::dicom_file::dicom_file ( dicom_dataset meta_info, dicom_dataset main_dataset )

private

Private constructor for internal use.

Definition at line 142 of file dicom_file.cpp.

    : meta_info_(std::move(meta_info)), dataset_(std::move(main_dataset)) {}

Member Function Documentation

create()

auto kcenon::pacs::core::dicom_file::create ( dicom_dataset dataset, const encoding::transfer_syntax & ts ) -> dicom_file

staticnodiscard

Create a new DICOM file from a dataset.

Parameters

dataset	The main dataset (SOP Class UID and Instance UID required)
ts	The transfer syntax to use for encoding

Returns

A new dicom_file with auto-generated File Meta Information

The File Meta Information will be automatically generated with:

• (0002,0001) File Meta Information Version = 0x00, 0x01
• (0002,0002) Media Storage SOP Class UID from dataset
• (0002,0003) Media Storage SOP Instance UID from dataset
• (0002,0010) Transfer Syntax UID
• (0002,0012) Implementation Class UID
• (0002,0013) Implementation Version Name

Examples

dcm_dir/main.cpp, get_scu/main.cpp, and retrieve_scu/main.cpp.

Definition at line 232 of file dicom_file.cpp.

                  {
    auto meta_info = generate_meta_information(dataset, ts);
    return dicom_file{std::move(meta_info), std::move(dataset)};
}

Referenced by kcenon::pacs::storage::file_storage::store(), kcenon::pacs::storage::azure_blob_storage::store_with_progress(), and kcenon::pacs::storage::s3_storage::store_with_progress().

Here is the caller graph for this function:

dataset() [1/2]

auto kcenon::pacs::core::dicom_file::dataset ( ) const -> const dicom_dataset&

nodiscardnoexcept

Get read-only access to the main dataset.

Returns

Const reference to the main dataset

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h, and module_example/main.cpp.

Definition at line 300 of file dicom_file.cpp.

                                                                {
    return dataset_;
}

References dataset_.

dataset() [2/2]

auto kcenon::pacs::core::dicom_file::dataset ( ) -> dicom_dataset&

nodiscardnoexcept

Get mutable access to the main dataset.

Returns

Reference to the main dataset

Definition at line 304 of file dicom_file.cpp.

                                                    {
    return dataset_;
}

References dataset_.

decode_dataset()

auto kcenon::pacs::core::dicom_file::decode_dataset ( std::span< const uint8_t > data, const encoding::transfer_syntax & ts, size_t & bytes_read ) -> kcenon::pacs::Result<dicom_dataset>

staticnodiscardprivate

Decode a dataset based on its Transfer Syntax.

Parameters

data	The raw byte data
ts	The Transfer Syntax to use for decoding
bytes_read	Output parameter for bytes consumed

Returns

Result containing the decoded dataset or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 993 of file dicom_file.cpp.

                                       {
 
    // Route to appropriate decoder based on Transfer Syntax properties
    if (ts.vr_type() == encoding::vr_encoding::implicit) {
        // Implicit VR Little Endian (only implicit is always LE)
        return decode_implicit_vr_le(data, bytes_read);
    }
 
    if (ts.endianness() == encoding::byte_order::big_endian) {
        // Explicit VR Big Endian
        return decode_explicit_vr_be(data, bytes_read);
    }
 
    // Explicit VR Little Endian (default and compressed transfer syntaxes)
    // Note: For compressed TS, pixel data is handled specially but
    // other elements are still Explicit VR LE
    return decode_explicit_vr_le(data, bytes_read);
}

References kcenon::pacs::encoding::big_endian, and kcenon::pacs::encoding::implicit.

decode_explicit_vr_be()

auto kcenon::pacs::core::dicom_file::decode_explicit_vr_be ( std::span< const uint8_t > data, size_t & bytes_read ) -> kcenon::pacs::Result<dicom_dataset>

staticnodiscardprivate

Decode a dataset from Explicit VR Big Endian format.

Parameters

data	The raw byte data
bytes_read	Output parameter for bytes consumed

Returns

Result containing the decoded dataset or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 765 of file dicom_file.cpp.

                                       {
    dicom_dataset dataset;
    size_t offset = 0;
 
    while (offset + 8 <= data.size()) {
        // Read tag (4 bytes, big-endian)
        const uint16_t group = read_uint16_be(data.subspan(offset, 2));
        const uint16_t element = read_uint16_be(data.subspan(offset + 2, 2));
        const dicom_tag tag{group, element};
 
        // Check for item/sequence delimiters
        if (group == kItemTagGroup) {
            break;
        }
 
        // Read VR (2 bytes ASCII)
        if (offset + 6 > data.size()) {
            break;
        }
 
        const char vr_chars[3] = {
            static_cast<char>(data[offset + 4]),
            static_cast<char>(data[offset + 5]),
            '\0'
        };
        const auto vr_opt = encoding::from_string(std::string_view(vr_chars, 2));
        // Unknown VR: fallback to UN per PS3.5 §6.2.2 (uses 4-byte length)
        const auto vr = vr_opt.value_or(encoding::vr_type::UN);
 
        // Determine length field size
        uint32_t length = 0;
        size_t header_size = 0;
 
        if (encoding::has_explicit_32bit_length(vr)) {
            if (offset + 12 > data.size()) {
                break;
            }
            // Skip 2 reserved bytes, then read 4-byte length (big-endian)
            length = read_uint32_be(data.subspan(offset + 8, 4));
            header_size = 12;
        } else {
            if (offset + 8 > data.size()) {
                break;
            }
            length = read_uint16_be(data.subspan(offset + 6, 2));
            header_size = 8;
        }
 
        // Handle undefined length
        if (length == kUndefinedLength) {
            if (vr == encoding::vr_type::SQ) {
                // Parse undefined length sequence
                size_t seq_bytes_read = 0;
                auto seq_result = parse_undefined_length_sequence(
                    data.subspan(offset + header_size),
                    seq_bytes_read, true, true);
 
                if (seq_result.is_ok()) {
                    // Create sequence element with parsed items
                    dicom_element seq_elem{tag, vr};
                    for (auto& item : seq_result.value()) {
                        seq_elem.add_sequence_item(std::move(item));
                    }
                    dataset.insert(std::move(seq_elem));
                }
                offset += header_size + seq_bytes_read;
                continue;
            }
            else if (tag == tags::pixel_data) {
                // Encapsulated pixel data (rare for big endian but handle it)
                size_t pixel_start = offset + header_size;
                size_t scan_offset = pixel_start;
 
                while (scan_offset + 8 <= data.size()) {
                    uint16_t g = read_uint16_be(data.subspan(scan_offset, 2));
                    uint16_t e = read_uint16_be(data.subspan(scan_offset + 2, 2));
 
                    if (g == kItemTagGroup && e == kSequenceDelimitationElement) {
                        scan_offset += 8;
                        break;
                    }
 
                    if (g == kItemTagGroup && e == kItemTagElement) {
                        scan_offset += 4;
                        if (scan_offset + 4 > data.size()) break;
                        uint32_t frag_len = read_uint32_be(data.subspan(scan_offset, 4));
                        scan_offset += 4 + frag_len;
                    } else {
                        break;
                    }
                }
 
                size_t encap_length = scan_offset - pixel_start;
                auto pixel_span = data.subspan(pixel_start, encap_length);
                dicom_element pixel_elem{tag, encoding::vr_type::OB, pixel_span};
                dataset.insert(std::move(pixel_elem));
 
                offset = scan_offset;
                continue;
            }
            else {
                break;
            }
        }
 
        // Validate value bounds
        if (offset + header_size + length > data.size()) {
            break;
        }
 
        // Read value - need to swap bytes for numeric types
        const auto value_data = data.subspan(offset + header_size, length);
        std::vector<uint8_t> swapped_data(value_data.begin(), value_data.end());
 
        // Swap bytes for numeric VRs
        if (encoding::is_numeric_vr(vr)) {
            const size_t element_size = encoding::fixed_length(vr);
            if (element_size == 2) {
                for (size_t i = 0; i + 1 < swapped_data.size(); i += 2) {
                    std::swap(swapped_data[i], swapped_data[i + 1]);
                }
            } else if (element_size == 4) {
                for (size_t i = 0; i + 3 < swapped_data.size(); i += 4) {
                    std::swap(swapped_data[i], swapped_data[i + 3]);
                    std::swap(swapped_data[i + 1], swapped_data[i + 2]);
                }
            } else if (element_size == 8) {
                for (size_t i = 0; i + 7 < swapped_data.size(); i += 8) {
                    std::swap(swapped_data[i], swapped_data[i + 7]);
                    std::swap(swapped_data[i + 1], swapped_data[i + 6]);
                    std::swap(swapped_data[i + 2], swapped_data[i + 5]);
                    std::swap(swapped_data[i + 3], swapped_data[i + 4]);
                }
            }
        }
 
        dicom_element elem{tag, vr, std::span<const uint8_t>(swapped_data)};
        dataset.insert(std::move(elem));
 
        offset += header_size + length;
    }
 
    bytes_read = offset;
    return kcenon::pacs::Result<dicom_dataset>::ok(std::move(dataset));
}

References kcenon::pacs::encoding::fixed_length(), kcenon::pacs::encoding::from_string(), kcenon::pacs::encoding::has_explicit_32bit_length(), kcenon::pacs::core::dicom_dataset::insert(), kcenon::pacs::encoding::is_numeric_vr(), kcenon::pacs::encoding::OB, kcenon::pacs::core::tags::pixel_data, kcenon::pacs::encoding::SQ, kcenon::pacs::encoding::UN, and vr.

Here is the call graph for this function:

decode_explicit_vr_le()

auto kcenon::pacs::core::dicom_file::decode_explicit_vr_le ( std::span< const uint8_t > data, size_t & bytes_read ) -> kcenon::pacs::Result<dicom_dataset>

staticnodiscardprivate

Decode a dataset from Explicit VR Little Endian format.

Parameters

data	The raw byte data
bytes_read	Output parameter for bytes consumed

Returns

Result containing the decoded dataset or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 500 of file dicom_file.cpp.

                                       {
    dicom_dataset dataset;
    size_t offset = 0;
 
    while (offset + 8 <= data.size()) {  // Minimum element size
        // Read tag (4 bytes)
        const uint16_t group = read_uint16_le(data.subspan(offset, 2));
        const uint16_t element = read_uint16_le(data.subspan(offset + 2, 2));
        const dicom_tag tag{group, element};
 
        // Skip item delimiter tags
        if (group == 0xFFFE) {
            break;
        }
 
        // Read VR (2 bytes)
        if (offset + 6 > data.size()) {
            break;
        }
 
        const char vr_chars[3] = {
            static_cast<char>(data[offset + 4]),
            static_cast<char>(data[offset + 5]),
            '\0'
        };
        const auto vr_opt = encoding::from_string(std::string_view(vr_chars, 2));
        // Unknown VR: fallback to UN per PS3.5 §6.2.2 (uses 4-byte length)
        const auto vr = vr_opt.value_or(encoding::vr_type::UN);
 
        // Determine length field size
        uint32_t length = 0;
        size_t header_size = 0;
 
        if (encoding::has_explicit_32bit_length(vr)) {
            if (offset + 12 > data.size()) {
                break;
            }
            length = read_uint32_le(data.subspan(offset + 8, 4));
            header_size = 12;
        } else {
            if (offset + 8 > data.size()) {
                break;
            }
            length = read_uint16_le(data.subspan(offset + 6, 2));
            header_size = 8;
        }
 
        // Handle undefined length (0xFFFFFFFF)
        if (length == kUndefinedLength) {
            if (vr == encoding::vr_type::SQ) {
                // Parse undefined length sequence
                size_t seq_bytes_read = 0;
                auto seq_result = parse_undefined_length_sequence(
                    data.subspan(offset + header_size),
                    seq_bytes_read, true, false);
 
                if (seq_result.is_ok()) {
                    // Create sequence element with parsed items
                    dicom_element seq_elem{tag, vr};
                    for (auto& item : seq_result.value()) {
                        seq_elem.add_sequence_item(std::move(item));
                    }
                    dataset.insert(std::move(seq_elem));
                }
                offset += header_size + seq_bytes_read;
                continue;
            }
            else if (tag == tags::pixel_data) {
                // Encapsulated pixel data - find sequence delimitation and store raw
                size_t pixel_start = offset + header_size;
                size_t scan_offset = pixel_start;
 
                // Scan for Sequence Delimitation Item
                while (scan_offset + 8 <= data.size()) {
                    uint16_t g = read_uint16_le(data.subspan(scan_offset, 2));
                    uint16_t e = read_uint16_le(data.subspan(scan_offset + 2, 2));
 
                    if (g == kItemTagGroup && e == kSequenceDelimitationElement) {
                        scan_offset += 8;  // Include delimitation item
                        break;
                    }
 
                    // Skip item tag and length
                    if (g == kItemTagGroup && e == kItemTagElement) {
                        scan_offset += 4;
                        if (scan_offset + 4 > data.size()) break;
                        uint32_t frag_len = read_uint32_le(data.subspan(scan_offset, 4));
                        scan_offset += 4 + frag_len;
                    } else {
                        break;  // Unexpected tag
                    }
                }
 
                // Store encapsulated data (OB VR for compressed pixel data)
                size_t encap_length = scan_offset - pixel_start;
                auto pixel_span = data.subspan(pixel_start, encap_length);
                dicom_element pixel_elem{tag, encoding::vr_type::OB, pixel_span};
                dataset.insert(std::move(pixel_elem));
 
                offset = scan_offset;
                continue;
            }
            else {
                // Unknown undefined length element - try to find delimiter
                break;
            }
        }
 
        // Validate value bounds
        if (offset + header_size + length > data.size()) {
            break;
        }
 
        // Read value and create element
        const auto value_data = data.subspan(offset + header_size, length);
        dicom_element elem{tag, vr, value_data};
        dataset.insert(std::move(elem));
 
        offset += header_size + length;
    }
 
    bytes_read = offset;
    return kcenon::pacs::Result<dicom_dataset>::ok(std::move(dataset));
}

References kcenon::pacs::encoding::from_string(), kcenon::pacs::encoding::has_explicit_32bit_length(), kcenon::pacs::core::dicom_dataset::insert(), kcenon::pacs::encoding::OB, kcenon::pacs::core::tags::pixel_data, kcenon::pacs::encoding::SQ, kcenon::pacs::encoding::UN, and vr.

Here is the call graph for this function:

decode_implicit_vr_le()

auto kcenon::pacs::core::dicom_file::decode_implicit_vr_le ( std::span< const uint8_t > data, size_t & bytes_read ) -> kcenon::pacs::Result<dicom_dataset>

staticnodiscardprivate

Decode a dataset from Implicit VR Little Endian format.

Parameters

data	The raw byte data
bytes_read	Output parameter for bytes consumed

Returns

Result containing the decoded dataset or error

Uses dicom_dictionary for VR lookup since VR is not encoded in data.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 627 of file dicom_file.cpp.

                                       {
    dicom_dataset dataset;
    size_t offset = 0;
    const auto& dict = dicom_dictionary::instance();
 
    while (offset + 8 <= data.size()) {
        // Read tag (4 bytes, little-endian)
        const uint16_t group = read_uint16_le(data.subspan(offset, 2));
        const uint16_t element = read_uint16_le(data.subspan(offset + 2, 2));
        const dicom_tag tag{group, element};
 
        // Check for item/sequence delimiters
        if (group == kItemTagGroup) {
            if (element == kSequenceDelimitationElement ||
                element == kItemDelimitationElement) {
                break;
            }
        }
 
        // Read length (4 bytes in Implicit VR)
        if (offset + 8 > data.size()) {
            break;
        }
        uint32_t length = read_uint32_le(data.subspan(offset + 4, 4));
 
        // Look up VR from dictionary
        auto tag_info = dict.find(tag);
        encoding::vr_type vr = encoding::vr_type::UN;
        if (tag_info) {
            auto vr_opt = encoding::from_string(
                encoding::to_string(static_cast<encoding::vr_type>(tag_info->vr)));
            if (vr_opt) {
                vr = *vr_opt;
            }
        }
 
        // For private data elements without dictionary entry, try creator-based lookup
        if (vr == encoding::vr_type::UN && tag.is_private_data()) {
            auto creator = dataset.get_private_creator(tag);
            if (creator) {
                auto block_num = tag.private_block_number();
                if (block_num) {
                    uint8_t elem_offset = static_cast<uint8_t>(
                        tag.element() & 0x00FF);
                    auto def = private_tag_registry::instance().find(
                        *creator, elem_offset);
                    if (def) {
                        vr = def->vr;
                    }
                }
            }
        }
 
        // Private Creator elements are always LO
        if (tag.is_private_creator()) {
            vr = encoding::vr_type::LO;
        }
 
        constexpr size_t kImplicitHeaderSize = 8;  // 4 bytes tag + 4 bytes length
 
        // Handle undefined length
        if (length == kUndefinedLength) {
            if (vr == encoding::vr_type::SQ) {
                // Parse undefined length sequence
                size_t seq_bytes_read = 0;
                auto seq_result = parse_undefined_length_sequence(
                    data.subspan(offset + kImplicitHeaderSize),
                    seq_bytes_read, false, false);
 
                if (seq_result.is_ok()) {
                    // Create sequence element with parsed items
                    dicom_element seq_elem{tag, vr};
                    for (auto& item : seq_result.value()) {
                        seq_elem.add_sequence_item(std::move(item));
                    }
                    dataset.insert(std::move(seq_elem));
                }
                offset += kImplicitHeaderSize + seq_bytes_read;
                continue;
            }
            else if (tag == tags::pixel_data) {
                // Encapsulated pixel data - find sequence delimitation and store raw
                size_t pixel_start = offset + kImplicitHeaderSize;
                size_t scan_offset = pixel_start;
 
                // Scan for Sequence Delimitation Item
                while (scan_offset + 8 <= data.size()) {
                    uint16_t g = read_uint16_le(data.subspan(scan_offset, 2));
                    uint16_t e = read_uint16_le(data.subspan(scan_offset + 2, 2));
 
                    if (g == kItemTagGroup && e == kSequenceDelimitationElement) {
                        scan_offset += 8;
                        break;
                    }
 
                    if (g == kItemTagGroup && e == kItemTagElement) {
                        scan_offset += 4;
                        if (scan_offset + 4 > data.size()) break;
                        uint32_t frag_len = read_uint32_le(data.subspan(scan_offset, 4));
                        scan_offset += 4 + frag_len;
                    } else {
                        break;
                    }
                }
 
                size_t encap_length = scan_offset - pixel_start;
                auto pixel_span = data.subspan(pixel_start, encap_length);
                dicom_element pixel_elem{tag, encoding::vr_type::OB, pixel_span};
                dataset.insert(std::move(pixel_elem));
 
                offset = scan_offset;
                continue;
            }
            else {
                // Unknown undefined length element
                break;
            }
        }
 
        // Validate value bounds
        if (offset + kImplicitHeaderSize + length > data.size()) {
            break;
        }
 
        // Read value and create element
        const auto value_data = data.subspan(offset + kImplicitHeaderSize, length);
        dicom_element elem{tag, vr, value_data};
        dataset.insert(std::move(elem));
 
        offset += kImplicitHeaderSize + length;
    }
 
    bytes_read = offset;
    return kcenon::pacs::Result<dicom_dataset>::ok(std::move(dataset));
}

References kcenon::pacs::encoding::from_string(), kcenon::pacs::core::dicom_dataset::get_private_creator(), kcenon::pacs::core::dicom_dataset::insert(), kcenon::pacs::core::dicom_dictionary::instance(), kcenon::pacs::core::private_tag_registry::instance(), kcenon::pacs::encoding::LO, kcenon::pacs::encoding::OB, kcenon::pacs::core::tags::pixel_data, kcenon::pacs::encoding::SQ, kcenon::pacs::encoding::to_string(), kcenon::pacs::encoding::UN, kcenon::pacs::core::tag_info::vr, and vr.

Here is the call graph for this function:

encode_dataset()

auto kcenon::pacs::core::dicom_file::encode_dataset ( const dicom_dataset & dataset, const encoding::transfer_syntax & ts ) -> std::vector<uint8_t>

staticnodiscardprivate

Encode a dataset based on its Transfer Syntax.

Parameters

dataset	The dataset to encode
ts	The Transfer Syntax to use for encoding

Returns

Encoded byte data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 1015 of file dicom_file.cpp.

                          {
 
    // Route to appropriate encoder based on Transfer Syntax properties
    if (ts.vr_type() == encoding::vr_encoding::implicit) {
        return encode_implicit_vr_le(dataset);
    }
 
    if (ts.endianness() == encoding::byte_order::big_endian) {
        return encode_explicit_vr_be(dataset);
    }
 
    // Explicit VR Little Endian (default)
    return encode_explicit_vr_le(dataset);
}

References kcenon::pacs::encoding::big_endian, and kcenon::pacs::encoding::implicit.

Referenced by to_bytes().

Here is the caller graph for this function:

encode_explicit_vr_be()

auto kcenon::pacs::core::dicom_file::encode_explicit_vr_be ( const dicom_dataset & dataset ) -> std::vector<uint8_t>

staticnodiscardprivate

Encode a dataset using Explicit VR Big Endian.

Parameters

dataset

The dataset to encode

Returns

Encoded byte data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 934 of file dicom_file.cpp.

                          {
    std::vector<uint8_t> result;
    result.reserve(65536);
 
    for (const auto& [tag, element] : dataset) {
        // Write tag (4 bytes, big-endian)
        write_uint16_be(result, tag.group());
        write_uint16_be(result, tag.element());
 
        // Write VR (2 bytes ASCII)
        const auto vr_str = encoding::to_string(element.vr());
        result.push_back(static_cast<uint8_t>(vr_str[0]));
        result.push_back(static_cast<uint8_t>(vr_str[1]));
 
        const auto& raw_data = element.raw_data();
        const auto length = static_cast<uint32_t>(raw_data.size());
 
        if (encoding::has_explicit_32bit_length(element.vr())) {
            // 2 reserved bytes + 4 byte length (big-endian)
            result.push_back(0x00);
            result.push_back(0x00);
            write_uint32_be(result, length);
        } else {
            // 2 byte length (big-endian)
            write_uint16_be(result, static_cast<uint16_t>(length));
        }
 
        // Write value - swap bytes for numeric types
        if (encoding::is_numeric_vr(element.vr())) {
            const size_t element_size = encoding::fixed_length(element.vr());
            std::vector<uint8_t> swapped_data(raw_data.begin(), raw_data.end());
 
            if (element_size == 2) {
                for (size_t i = 0; i + 1 < swapped_data.size(); i += 2) {
                    std::swap(swapped_data[i], swapped_data[i + 1]);
                }
            } else if (element_size == 4) {
                for (size_t i = 0; i + 3 < swapped_data.size(); i += 4) {
                    std::swap(swapped_data[i], swapped_data[i + 3]);
                    std::swap(swapped_data[i + 1], swapped_data[i + 2]);
                }
            } else if (element_size == 8) {
                for (size_t i = 0; i + 7 < swapped_data.size(); i += 8) {
                    std::swap(swapped_data[i], swapped_data[i + 7]);
                    std::swap(swapped_data[i + 1], swapped_data[i + 6]);
                    std::swap(swapped_data[i + 2], swapped_data[i + 5]);
                    std::swap(swapped_data[i + 3], swapped_data[i + 4]);
                }
            }
            result.insert(result.end(), swapped_data.begin(), swapped_data.end());
        } else {
            result.insert(result.end(), raw_data.begin(), raw_data.end());
        }
    }
 
    return result;
}

References kcenon::pacs::encoding::fixed_length(), kcenon::pacs::encoding::has_explicit_32bit_length(), kcenon::pacs::encoding::is_numeric_vr(), and kcenon::pacs::encoding::to_string().

Here is the call graph for this function:

encode_explicit_vr_le()

auto kcenon::pacs::core::dicom_file::encode_explicit_vr_le ( const dicom_dataset & dataset ) -> std::vector<uint8_t>

staticnodiscardprivate

Encode a dataset using Explicit VR Little Endian.

Parameters

dataset

The dataset to encode

Returns

Encoded byte data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 465 of file dicom_file.cpp.

                          {
    std::vector<uint8_t> result;
    result.reserve(65536);  // Initial estimate
 
    for (const auto& [tag, element] : dataset) {
        // Write tag (4 bytes, little-endian)
        write_uint16_le(result, tag.group());
        write_uint16_le(result, tag.element());
 
        // Write VR (2 bytes)
        const auto vr_str = encoding::to_string(element.vr());
        result.push_back(static_cast<uint8_t>(vr_str[0]));
        result.push_back(static_cast<uint8_t>(vr_str[1]));
 
        const auto& raw_data = element.raw_data();
        const auto length = static_cast<uint32_t>(raw_data.size());
 
        if (encoding::has_explicit_32bit_length(element.vr())) {
            // 2 reserved bytes + 4 byte length
            result.push_back(0x00);
            result.push_back(0x00);
            write_uint32_le(result, length);
        } else {
            // 2 byte length
            write_uint16_le(result, static_cast<uint16_t>(length));
        }
 
        // Write value
        result.insert(result.end(), raw_data.begin(), raw_data.end());
    }
 
    return result;
}

References kcenon::pacs::encoding::has_explicit_32bit_length(), and kcenon::pacs::encoding::to_string().

Referenced by to_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_implicit_vr_le()

auto kcenon::pacs::core::dicom_file::encode_implicit_vr_le ( const dicom_dataset & dataset ) -> std::vector<uint8_t>

staticnodiscardprivate

Encode a dataset using Implicit VR Little Endian.

Parameters

dataset

The dataset to encode

Returns

Encoded byte data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 913 of file dicom_file.cpp.

                          {
    std::vector<uint8_t> result;
    result.reserve(65536);
 
    for (const auto& [tag, element] : dataset) {
        // Write tag (4 bytes, little-endian)
        write_uint16_le(result, tag.group());
        write_uint16_le(result, tag.element());
 
        // Write length (4 bytes in Implicit VR)
        const auto& raw_data = element.raw_data();
        write_uint32_le(result, static_cast<uint32_t>(raw_data.size()));
 
        // Write value
        result.insert(result.end(), raw_data.begin(), raw_data.end());
    }
 
    return result;
}

from_bytes()

auto kcenon::pacs::core::dicom_file::from_bytes ( std::span< const uint8_t > data ) -> kcenon::pacs::Result<dicom_file>

staticnodiscard

Parse a DICOM file from raw bytes.

Parameters

data	Raw byte data of the DICOM file

Returns

Result containing the parsed file or an error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 166 of file dicom_file.cpp.

                                    {
    // Minimum size: 128 (preamble) + 4 (DICM) + minimal meta info
    if (data.size() < kPreambleSize + 4) {
        return kcenon::pacs::pacs_error<dicom_file>(
            kcenon::pacs::error_codes::invalid_dicom_file,
            "File too small to be valid DICOM Part 10 file");
    }
 
    // Check for DICM prefix at offset 128
    const auto prefix = data.subspan(kPreambleSize, 4);
    if (std::memcmp(prefix.data(), kDicmPrefix, 4) != 0) {
        return kcenon::pacs::pacs_error<dicom_file>(
            kcenon::pacs::error_codes::missing_dicm_prefix,
            "Missing DICM prefix at offset 128");
    }
 
    // Parse File Meta Information (starts after preamble + DICM)
    const auto meta_start = data.subspan(kPreambleSize + 4);
    size_t meta_bytes_read = 0;
 
    auto meta_result = parse_meta_information(meta_start, meta_bytes_read);
    if (meta_result.is_err()) {
        return kcenon::pacs::Result<dicom_file>::err(meta_result.error());
    }
 
    // Extract Transfer Syntax from meta information
    const auto* ts_elem = meta_result.value().get(tags::transfer_syntax_uid);
    if (ts_elem == nullptr) {
        return kcenon::pacs::pacs_error<dicom_file>(
            kcenon::pacs::error_codes::missing_transfer_syntax,
            "Transfer Syntax UID not found in meta information");
    }
 
    auto ts_uid_result = ts_elem->as_string();
    if (ts_uid_result.is_err()) {
        return kcenon::pacs::pacs_error<dicom_file>(
            kcenon::pacs::error_codes::value_conversion_error,
            "Failed to read Transfer Syntax UID");
    }
    const auto ts_uid = ts_uid_result.value();
    encoding::transfer_syntax ts{ts_uid};
 
    if (!ts.is_valid()) {
        return kcenon::pacs::pacs_error<dicom_file>(
            kcenon::pacs::error_codes::unsupported_transfer_syntax,
            "Unsupported Transfer Syntax: " + ts_uid);
    }
 
    // Parse main dataset using appropriate decoder based on Transfer Syntax
    const auto dataset_start = meta_start.subspan(meta_bytes_read);
    size_t dataset_bytes_read = 0;
 
    auto dataset_result = decode_dataset(dataset_start, ts, dataset_bytes_read);
    if (dataset_result.is_err()) {
        return kcenon::pacs::Result<dicom_file>::err(dataset_result.error());
    }
 
    return kcenon::pacs::Result<dicom_file>::ok(
        dicom_file{std::move(meta_result.value()), std::move(dataset_result.value())});
}

References kcenon::pacs::error_codes::invalid_dicom_file, kcenon::pacs::error_codes::missing_dicm_prefix, kcenon::pacs::error_codes::missing_transfer_syntax, kcenon::pacs::pacs_error(), kcenon::pacs::core::tags::transfer_syntax_uid, kcenon::pacs::error_codes::unsupported_transfer_syntax, and kcenon::pacs::error_codes::value_conversion_error.

Referenced by kcenon::pacs::storage::azure_blob_storage::find(), kcenon::pacs::storage::s3_storage::find(), kcenon::pacs::storage::azure_blob_storage::rebuild_index(), kcenon::pacs::storage::s3_storage::rebuild_index(), kcenon::pacs::web::dicomweb::render_dicom_image(), kcenon::pacs::storage::azure_blob_storage::retrieve_with_progress(), and kcenon::pacs::storage::s3_storage::retrieve_with_progress().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_meta_information()

auto kcenon::pacs::core::dicom_file::generate_meta_information ( const dicom_dataset & dataset, const encoding::transfer_syntax & ts ) -> dicom_dataset

staticnodiscardprivate

Generate File Meta Information for a dataset.

Parameters

dataset	The main dataset
ts	The transfer syntax

Returns

The generated meta information dataset

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 412 of file dicom_file.cpp.

                     {
    dicom_dataset meta_info;
 
    // (0002,0001) File Meta Information Version
    const uint8_t version_bytes[] = {0x00, 0x01};
    meta_info.insert(dicom_element{
        tags::file_meta_information_version,
        encoding::vr_type::OB,
        std::span<const uint8_t>(version_bytes, 2)
    });
 
    // (0002,0002) Media Storage SOP Class UID
    const auto sop_class = dataset.get_string(tags::sop_class_uid);
    meta_info.set_string(
        tags::media_storage_sop_class_uid,
        encoding::vr_type::UI,
        sop_class
    );
 
    // (0002,0003) Media Storage SOP Instance UID
    const auto sop_instance = dataset.get_string(tags::sop_instance_uid);
    meta_info.set_string(
        tags::media_storage_sop_instance_uid,
        encoding::vr_type::UI,
        sop_instance
    );
 
    // (0002,0010) Transfer Syntax UID
    meta_info.set_string(
        tags::transfer_syntax_uid,
        encoding::vr_type::UI,
        std::string(ts.uid())
    );
 
    // (0002,0012) Implementation Class UID
    meta_info.set_string(
        tags::implementation_class_uid,
        encoding::vr_type::UI,
        std::string(kImplementationClassUid)
    );
 
    // (0002,0013) Implementation Version Name
    meta_info.set_string(
        tags::implementation_version_name,
        encoding::vr_type::SH,
        std::string(kImplementationVersionName)
    );
 
    return meta_info;
}

References kcenon::pacs::core::tags::file_meta_information_version, kcenon::pacs::core::tags::implementation_class_uid, kcenon::pacs::core::tags::implementation_version_name, kcenon::pacs::core::dicom_dataset::insert(), kcenon::pacs::core::tags::media_storage_sop_class_uid, kcenon::pacs::core::tags::media_storage_sop_instance_uid, kcenon::pacs::encoding::OB, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::encoding::SH, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, kcenon::pacs::core::tags::transfer_syntax_uid, and kcenon::pacs::encoding::UI.

Here is the call graph for this function:

meta_information() [1/2]

auto kcenon::pacs::core::dicom_file::meta_information ( ) const -> const dicom_dataset&

nodiscardnoexcept

Get read-only access to the File Meta Information.

Returns

Const reference to the meta information dataset

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 292 of file dicom_file.cpp.

                                                                         {
    return meta_info_;
}

References meta_info_.

meta_information() [2/2]

auto kcenon::pacs::core::dicom_file::meta_information ( ) -> dicom_dataset&

nodiscardnoexcept

Get mutable access to the File Meta Information.

Returns

Reference to the meta information dataset

Definition at line 296 of file dicom_file.cpp.

                                                             {
    return meta_info_;
}

References meta_info_.

open()

auto kcenon::pacs::core::dicom_file::open ( const std::filesystem::path & path ) -> kcenon::pacs::Result<dicom_file>

staticnodiscard

Open and read a DICOM file from disk.

Parameters

path	Path to the DICOM file

Returns

Result containing the parsed file or an error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 149 of file dicom_file.cpp.

                                    {
    // Try memory-mapped I/O first for better performance
    auto mmap_result = memory_mapped_file::open(path);
    if (mmap_result.is_ok()) {
        return from_bytes(mmap_result.value().as_span());
    }
 
    // Fall back to traditional file I/O
    auto contents = read_file_contents(path);
    if (contents.is_err()) {
        return kcenon::pacs::Result<dicom_file>::err(contents.error());
    }
 
    return from_bytes(contents.value());
}

References kcenon::pacs::core::memory_mapped_file::open().

Referenced by kcenon::pacs::storage::file_storage::find(), kcenon::pacs::web::metadata_service::get_frame_info(), kcenon::pacs::web::metadata_service::get_sorted_instances(), kcenon::pacs::storage::file_storage::get_statistics(), kcenon::pacs::web::metadata_service::get_voi_lut(), kcenon::pacs::example::pacs_server_app::handle_retrieve(), kcenon::pacs::storage::file_storage::import_directory(), kcenon::pacs::web::metadata_service::read_dicom_tags(), kcenon::pacs::storage::file_storage::rebuild_index(), kcenon::pacs::storage::file_storage::retrieve(), kcenon::pacs::services::storage_scu::store_file(), and kcenon::pacs::storage::file_storage::verify_integrity().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

auto kcenon::pacs::core::dicom_file::operator= ( const dicom_file & ) -> dicom_file &=default

default

Copy assignment.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

operator=() [2/2]

auto kcenon::pacs::core::dicom_file::operator= ( dicom_file && ) -> dicom_file &=default

defaultnoexcept

Move assignment.

parse_encapsulated_frames()

auto kcenon::pacs::core::dicom_file::parse_encapsulated_frames ( std::span< const uint8_t > data ) -> std::vector<std::vector<uint8_t>>

staticnodiscardprivate

Parse encapsulated pixel data frames.

Parameters

data	The raw encapsulated pixel data

Returns

Vector of frame data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 1119 of file dicom_file.cpp.

                                     {
 
    std::vector<std::vector<uint8_t>> frames;
    size_t offset = 0;
 
    // First item is Basic Offset Table (may be empty)
    if (offset + 8 <= data.size()) {
        const uint16_t group = read_uint16_le(data.subspan(offset, 2));
        const uint16_t element = read_uint16_le(data.subspan(offset + 2, 2));
 
        if (group == kItemTagGroup && element == kItemTagElement) {
            uint32_t bot_length = read_uint32_le(data.subspan(offset + 4, 4));
            offset += 8 + bot_length;  // Skip BOT
        }
    }
 
    // Parse fragment items
    while (offset + 8 <= data.size()) {
        const uint16_t group = read_uint16_le(data.subspan(offset, 2));
        const uint16_t element = read_uint16_le(data.subspan(offset + 2, 2));
 
        // Check for sequence delimitation
        if (group == kItemTagGroup && element == kSequenceDelimitationElement) {
            break;
        }
 
        // Must be an item tag
        if (group != kItemTagGroup || element != kItemTagElement) {
            break;
        }
 
        uint32_t fragment_length = read_uint32_le(data.subspan(offset + 4, 4));
        offset += 8;
 
        if (offset + fragment_length > data.size()) {
            break;
        }
 
        // Copy fragment data
        std::vector<uint8_t> fragment(
            data.begin() + static_cast<std::ptrdiff_t>(offset),
            data.begin() + static_cast<std::ptrdiff_t>(offset + fragment_length));
        frames.push_back(std::move(fragment));
 
        offset += fragment_length;
    }
 
    return frames;
}

parse_meta_information()

auto kcenon::pacs::core::dicom_file::parse_meta_information ( std::span< const uint8_t > data, size_t & bytes_read ) -> kcenon::pacs::Result<dicom_dataset>

staticnodiscardprivate

Parse file meta information from raw data.

Parameters

data	Raw byte data starting at the meta information
bytes_read	Output parameter for bytes consumed

Returns

Result containing the parsed meta info or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 329 of file dicom_file.cpp.

                                       {
    // File Meta Information is always encoded as Explicit VR Little Endian
    // First, we need to find the group length to know how much to read
 
    dicom_dataset meta_info;
    size_t offset = 0;
 
    // Parse elements until we leave group 0x0002 or run out of data
    while (offset + 8 <= data.size()) {  // Minimum element size: 8 bytes
        // Read tag (4 bytes)
        const uint16_t group = read_uint16_le(data.subspan(offset, 2));
        const uint16_t element = read_uint16_le(data.subspan(offset + 2, 2));
        const dicom_tag tag{group, element};
 
        // Stop if we've left the meta information group
        if (group != 0x0002) {
            break;
        }
 
        // Read VR (2 bytes)
        if (offset + 6 > data.size()) {
            return kcenon::pacs::pacs_error<dicom_dataset>(
                kcenon::pacs::error_codes::decode_error,
                "Unexpected end of data while reading VR");
        }
 
        const char vr_chars[3] = {
            static_cast<char>(data[offset + 4]),
            static_cast<char>(data[offset + 5]),
            '\0'
        };
        const auto vr_opt = encoding::from_string(std::string_view(vr_chars, 2));
        if (!vr_opt) {
            return kcenon::pacs::pacs_error<dicom_dataset>(
                kcenon::pacs::error_codes::decode_error,
                "Invalid VR: " + std::string(vr_chars, 2));
        }
        const auto vr = *vr_opt;
 
        // Determine length field size based on VR
        uint32_t length = 0;
        size_t header_size = 0;
 
        if (encoding::has_explicit_32bit_length(vr)) {
            // VR + 2 reserved bytes + 4 byte length
            if (offset + 12 > data.size()) {
                return kcenon::pacs::pacs_error<dicom_dataset>(
                    kcenon::pacs::error_codes::decode_error,
                    "Unexpected end of data while reading length field");
            }
            length = read_uint32_le(data.subspan(offset + 8, 4));
            header_size = 12;
        } else {
            // VR + 2 byte length
            if (offset + 8 > data.size()) {
                return kcenon::pacs::pacs_error<dicom_dataset>(
                    kcenon::pacs::error_codes::decode_error,
                    "Unexpected end of data while reading length field");
            }
            length = read_uint16_le(data.subspan(offset + 6, 2));
            header_size = 8;
        }
 
        // Validate and read value
        if (offset + header_size + length > data.size()) {
            return kcenon::pacs::pacs_error<dicom_dataset>(
                kcenon::pacs::error_codes::decode_error,
                "Value length exceeds available data");
        }
 
        const auto value_data = data.subspan(offset + header_size, length);
        dicom_element elem{tag, vr, value_data};
        meta_info.insert(std::move(elem));
 
        offset += header_size + length;
    }
 
    bytes_read = offset;
    return kcenon::pacs::Result<dicom_dataset>::ok(std::move(meta_info));
}

References kcenon::pacs::error_codes::decode_error, kcenon::pacs::encoding::from_string(), kcenon::pacs::encoding::has_explicit_32bit_length(), kcenon::pacs::core::dicom_dataset::insert(), kcenon::pacs::pacs_error(), and vr.

Here is the call graph for this function:

parse_undefined_length_sequence()

auto kcenon::pacs::core::dicom_file::parse_undefined_length_sequence ( std::span< const uint8_t > data, size_t & bytes_read, bool explicit_vr, bool big_endian ) -> kcenon::pacs::Result<std::vector<dicom_dataset>>

staticnodiscardprivate

Parse a sequence with undefined length.

Parameters

data	The raw byte data starting at sequence value
bytes_read	Output parameter for bytes consumed
explicit_vr	Whether to use explicit VR parsing
big_endian	Whether data is big endian

Returns

Result containing the sequence items or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 1032 of file dicom_file.cpp.

                                                  {
 
    std::vector<dicom_dataset> items;
    size_t offset = 0;
 
    // Helper function pointers for reading based on endianness
    auto read_u16 = big_endian ? read_uint16_be : read_uint16_le;
    auto read_u32 = big_endian ? read_uint32_be : read_uint32_le;
 
    while (offset + 8 <= data.size()) {
        // Read item tag
        const uint16_t group = read_u16(data.subspan(offset, 2));
        const uint16_t element = read_u16(data.subspan(offset + 2, 2));
 
        // Check for sequence delimitation item
        if (group == kItemTagGroup && element == kSequenceDelimitationElement) {
            // Read length (should be 0)
            offset += 8;
            break;
        }
 
        // Must be an item tag (FFFE,E000)
        if (group != kItemTagGroup || element != kItemTagElement) {
            break;  // Unexpected tag
        }
 
        // Read item length
        uint32_t item_length = read_u32(data.subspan(offset + 4, 4));
        offset += 8;
 
        if (item_length == kUndefinedLength) {
            // Item with undefined length - find item delimitation tag
            size_t item_end = offset;
            while (item_end + 8 <= data.size()) {
                uint16_t g = read_u16(data.subspan(item_end, 2));
                uint16_t e = read_u16(data.subspan(item_end + 2, 2));
                if (g == kItemTagGroup && e == kItemDelimitationElement) {
                    break;
                }
                // Simple skip - move forward by element
                // This is a simplified approach; full implementation would parse elements
                item_end += 4;
                if (item_end + 4 > data.size()) break;
                uint32_t len = read_u32(data.subspan(item_end, 4));
                item_end += 4;
                if (len != kUndefinedLength) {
                    item_end += len;
                }
            }
            // Parse item content
            size_t item_bytes_read = 0;
            auto item_data = data.subspan(offset, item_end - offset);
            kcenon::pacs::Result<dicom_dataset> item_result = explicit_vr
                ? (big_endian ? decode_explicit_vr_be(item_data, item_bytes_read)
                              : decode_explicit_vr_le(item_data, item_bytes_read))
                : decode_implicit_vr_le(item_data, item_bytes_read);
 
            if (item_result.is_ok()) {
                items.push_back(std::move(item_result.value()));
            }
            offset = item_end + 8;  // Skip delimitation item
        } else {
            // Item with defined length
            if (offset + item_length > data.size()) {
                break;
            }
            size_t item_bytes_read = 0;
            auto item_data = data.subspan(offset, item_length);
            kcenon::pacs::Result<dicom_dataset> item_result = explicit_vr
                ? (big_endian ? decode_explicit_vr_be(item_data, item_bytes_read)
                              : decode_explicit_vr_le(item_data, item_bytes_read))
                : decode_implicit_vr_le(item_data, item_bytes_read);
 
            if (item_result.is_ok()) {
                items.push_back(std::move(item_result.value()));
            }
            offset += item_length;
        }
    }
 
    bytes_read = offset;
    return kcenon::pacs::Result<std::vector<dicom_dataset>>::ok(std::move(items));
}

save()

auto kcenon::pacs::core::dicom_file::save ( const std::filesystem::path & path ) const -> kcenon::pacs::VoidResult

nodiscard

Save the DICOM file to disk.

Parameters

path	Destination file path

Returns

Result indicating success or failure

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 243 of file dicom_file.cpp.

                            {
    auto bytes = to_bytes();
 
    std::ofstream file(path, std::ios::binary);
    if (!file) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::file_write_error,
            "Failed to open file for writing: " + path.string());
    }
 
    if (!file.write(reinterpret_cast<const char*>(bytes.data()),
                    static_cast<std::streamsize>(bytes.size()))) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::file_write_error,
            "Failed to write to file: " + path.string());
    }
 
    return kcenon::pacs::ok();
}

References kcenon::pacs::error_codes::file_write_error, and kcenon::pacs::pacs_void_error().

Here is the call graph for this function:

sop_class_uid()

auto kcenon::pacs::core::dicom_file::sop_class_uid ( ) const -> std::string

nodiscard

Get the SOP Class UID.

Returns

The SOP Class UID from the main dataset

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 317 of file dicom_file.cpp.

                                                  {
    return dataset_.get_string(tags::sop_class_uid);
}

References dataset_, kcenon::pacs::core::dicom_dataset::get_string(), and kcenon::pacs::core::tags::sop_class_uid.

Here is the call graph for this function:

sop_instance_uid()

auto kcenon::pacs::core::dicom_file::sop_instance_uid ( ) const -> std::string

nodiscard

Get the SOP Instance UID.

Returns

The SOP Instance UID from the main dataset

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 321 of file dicom_file.cpp.

                                                     {
    return dataset_.get_string(tags::sop_instance_uid);
}

References dataset_, kcenon::pacs::core::dicom_dataset::get_string(), and kcenon::pacs::core::tags::sop_instance_uid.

Here is the call graph for this function:

to_bytes()

auto kcenon::pacs::core::dicom_file::to_bytes ( ) const -> std::vector<uint8_t>

nodiscard

Encode the DICOM file to raw bytes.

Returns

Vector containing the encoded file data

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 264 of file dicom_file.cpp.

                                                      {
    std::vector<uint8_t> result;
 
    // Reserve estimated size
    result.reserve(kPreambleSize + 4 + 512 + 65536);
 
    // Write 128-byte preamble (zeros)
    result.resize(kPreambleSize, 0);
 
    // Write DICM prefix
    result.insert(result.end(), std::begin(kDicmPrefix), std::end(kDicmPrefix));
 
    // Encode and write File Meta Information (always Explicit VR LE)
    auto meta_bytes = encode_explicit_vr_le(meta_info_);
    result.insert(result.end(), meta_bytes.begin(), meta_bytes.end());
 
    // Encode and write main dataset using appropriate Transfer Syntax
    auto ts = transfer_syntax();
    auto dataset_bytes = encode_dataset(dataset_, ts);
    result.insert(result.end(), dataset_bytes.begin(), dataset_bytes.end());
 
    return result;
}

References dataset_, encode_dataset(), encode_explicit_vr_le(), kDicmPrefix, kPreambleSize, meta_info_, and transfer_syntax().

Here is the call graph for this function:

transfer_syntax()

auto kcenon::pacs::core::dicom_file::transfer_syntax ( ) const -> encoding::transfer_syntax

nodiscard

Get the Transfer Syntax of this file.

Returns

The transfer syntax (from File Meta Information)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 312 of file dicom_file.cpp.

                                                                  {
    const auto ts_uid = meta_info_.get_string(tags::transfer_syntax_uid);
    return encoding::transfer_syntax{ts_uid};
}

References kcenon::pacs::core::dicom_dataset::get_string(), meta_info_, and kcenon::pacs::core::tags::transfer_syntax_uid.

Referenced by to_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

dataset_

dicom_dataset kcenon::pacs::core::dicom_file::dataset_

private

Main dataset (encoded per Transfer Syntax)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 346 of file dicom_file.h.

Referenced by dataset(), dataset(), sop_class_uid(), sop_instance_uid(), and to_bytes().

kDicmPrefix

uint8_t kcenon::pacs::core::dicom_file::kDicmPrefix[4] = {'D', 'I', 'C', 'M'}

staticconstexprprivate

DICOM magic bytes.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 356 of file dicom_file.h.

{'D', 'I', 'C', 'M'};

Referenced by to_bytes().

kImplementationClassUid

std::string_view kcenon::pacs::core::dicom_file::kImplementationClassUid

staticconstexprprivate

Initial value:

=
        "1.2.826.0.1.3680043.8.1055.1"

Implementation Class UID for this library.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 349 of file dicom_file.h.

kImplementationVersionName

std::string_view kcenon::pacs::core::dicom_file::kImplementationVersionName = "PACS_SYS_001"

staticconstexprprivate

Implementation Version Name.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 353 of file dicom_file.h.

kPreambleSize

size_t kcenon::pacs::core::dicom_file::kPreambleSize = 128

staticconstexprprivate

Preamble size.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 359 of file dicom_file.h.

Referenced by to_bytes().

meta_info_

dicom_dataset kcenon::pacs::core::dicom_file::meta_info_

private

File Meta Information (Group 0002)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/core/dicom_file.h.

Definition at line 343 of file dicom_file.h.

Referenced by meta_information(), meta_information(), to_bytes(), and transfer_syntax().

---

The documentation for this class was generated from the following files:

• include/kcenon/pacs/core/dicom_file.h
• src/core/dicom_file.cpp