Service for selective metadata retrieval and series navigation. More...

#include <metadata_service.h>

Collaboration diagram for kcenon::pacs::web::metadata_service:

Public Member Functions
	metadata_service (std::shared_ptr< storage::index_database > database)
	Construct metadata service with database.

	~metadata_service ()
	Destructor.

	metadata_service (const metadata_service &)=delete
	Non-copyable, non-movable.

metadata_service &	operator= (const metadata_service &)=delete

	metadata_service (metadata_service &&)=delete

metadata_service &	operator= (metadata_service &&)=delete

metadata_response	get_metadata (std::string_view sop_instance_uid, const metadata_request &request)
	Get selective metadata for an instance.

sorted_instances_response	get_sorted_instances (std::string_view series_uid, sort_order order=sort_order::position, bool ascending=true)
	Get sorted instances for a series.

navigation_info	get_navigation (std::string_view sop_instance_uid)
	Get navigation info for an instance.

voi_lut_info	get_voi_lut (std::string_view sop_instance_uid)
	Get VOI LUT info from an instance.

frame_info	get_frame_info (std::string_view sop_instance_uid)
	Get frame information for an instance.

Static Public Member Functions
static std::unordered_set< std::string >	get_preset_tags (metadata_preset preset)
	Get tags for a specific preset.

static std::vector< window_level_preset >	get_window_level_presets (std::string_view modality)
	Get window/level presets for a modality.

Private Member Functions
std::unordered_map< std::string, std::string >	read_dicom_tags (std::string_view file_path, const std::unordered_set< std::string > &requested_tags, bool include_private)
	Read DICOM dataset from file.

std::optional< std::string >	get_series_uid (std::string_view sop_instance_uid)
	Get series UID for an instance.

Private Attributes
std::shared_ptr< storage::index_database >	database_
	Database for instance lookups.

Detailed Description

Service for selective metadata retrieval and series navigation.

Provides APIs for:

Selective DICOM tag retrieval with presets
Series instance sorting and navigation
Window/Level preset management
Multi-frame information

Definition at line 344 of file metadata_service.h.

Constructor & Destructor Documentation

◆ metadata_service() [1/3]

kcenon::pacs::web::metadata_service::metadata_service ( std::shared_ptr< storage::index_database > database )

explicit

Construct metadata service with database.

Parameters

database Index database for instance lookups

Definition at line 172 of file metadata_service.cpp.

174 : database_(std::move(database)) {}

kcenon::pacs::web::metadata_service::database_

std::shared_ptr< storage::index_database > database_

Database for instance lookups.

Definition metadata_service.h:440

◆ ~metadata_service()

kcenon::pacs::web::metadata_service::~metadata_service ( )

default

Destructor.

◆ metadata_service() [2/3]

kcenon::pacs::web::metadata_service::metadata_service ( const metadata_service & )

delete

Non-copyable, non-movable.

◆ metadata_service() [3/3]

kcenon::pacs::web::metadata_service::metadata_service ( metadata_service && )

delete

Member Function Documentation

◆ get_frame_info()

frame_info kcenon::pacs::web::metadata_service::get_frame_info ( std::string_view sop_instance_uid )

nodiscard

Get frame information for an instance.

Parameters

sop_instance_uid SOP Instance UID

Returns: Frame information

Definition at line 641 of file metadata_service.cpp.

                                                                           {
    if (database_ == nullptr) {
        return frame_info::error("Database not configured");
    }
 
    auto instance = database_->find_instance(sop_instance_uid);
    if (!instance) {
        return frame_info::error("Instance not found");
    }
 
    if (!std::filesystem::exists(instance->file_path)) {
        return frame_info::error("DICOM file not found");
    }
 
    auto file_result =
        kcenon::pacs::core::dicom_file::open(std::filesystem::path(instance->file_path));
    if (file_result.is_err()) {
        return frame_info::error("Failed to open DICOM file");
    }
 
    const auto& ds = file_result.value().dataset();
 
    frame_info info = frame_info::ok();
 
    // Number of Frames (0028,0008)
    const auto* nf_elem = ds.get(kcenon::pacs::core::dicom_tag{0x0028, 0x0008});
    if (nf_elem != nullptr) {
        auto nf_result = nf_elem->as_string();
        if (nf_result.is_ok()) {
            try {
                info.total_frames = static_cast<uint32_t>(std::stoul(nf_result.value()));
            } catch (...) {
                info.total_frames = 1;
            }
        }
    }
 
    // Frame Time (0018,1063) - in milliseconds
    const auto* ft_elem = ds.get(kcenon::pacs::core::dicom_tag{0x0018, 0x1063});
    if (ft_elem != nullptr) {
        auto ft_result = ft_elem->as_string();
        if (ft_result.is_ok()) {
            try {
                info.frame_time = std::stod(ft_result.value());
                if (info.frame_time.has_value() && info.frame_time.value() > 0) {
                    info.frame_rate = 1000.0 / info.frame_time.value();
                }
            } catch (...) {
            }
        }
    }
 
    // Rows
    auto rows_opt = ds.get_numeric<uint16_t>(kcenon::pacs::core::tags::rows);
    if (rows_opt.has_value()) {
        info.rows = rows_opt.value();
    }
 
    // Columns
    auto cols_opt = ds.get_numeric<uint16_t>(kcenon::pacs::core::tags::columns);
    if (cols_opt.has_value()) {
        info.columns = cols_opt.value();
    }
 
    return info;
}

References kcenon::pacs::core::tags::columns, database_, kcenon::pacs::web::frame_info::error(), kcenon::pacs::web::frame_info::ok(), kcenon::pacs::core::dicom_file::open(), and kcenon::pacs::core::tags::rows.

Here is the call graph for this function:

◆ get_metadata()

metadata_response kcenon::pacs::web::metadata_service::get_metadata	(	std::string_view	sop_instance_uid,
		const metadata_request &	request )

nodiscard

Get selective metadata for an instance.

Parameters

sop_instance_uid	SOP Instance UID
request	Metadata request parameters

Returns: Metadata response with requested tags

Definition at line 259 of file metadata_service.cpp.

                                                                      {
    if (database_ == nullptr) {
        return metadata_response::error("Database not configured");
    }
 
    // Find instance
    auto instance = database_->find_instance(sop_instance_uid);
    if (!instance) {
        return metadata_response::error("Instance not found");
    }
 
    // Check file exists
    if (!std::filesystem::exists(instance->file_path)) {
        return metadata_response::error("DICOM file not found");
    }
 
    // Build set of requested tags
    std::unordered_set<std::string> requested_tags;
 
    // Add preset tags if specified
    if (request.preset.has_value()) {
        auto preset_tags = get_preset_tags(request.preset.value());
        requested_tags.insert(preset_tags.begin(), preset_tags.end());
    }
 
    // Add explicitly requested tags
    for (const auto& tag : request.tags) {
        requested_tags.insert(tag);
    }
 
    // If no tags specified, return error
    if (requested_tags.empty()) {
        return metadata_response::error(
            "No tags specified: provide 'tags' or 'preset' parameter");
    }
 
    // Read and filter DICOM tags
    auto tag_values =
        read_dicom_tags(instance->file_path, requested_tags, request.include_private);
 
    return metadata_response::ok(std::move(tag_values));
}

References database_, kcenon::pacs::web::metadata_response::error(), get_preset_tags(), kcenon::pacs::web::metadata_request::include_private, kcenon::pacs::web::metadata_response::ok(), kcenon::pacs::web::metadata_request::preset, read_dicom_tags(), and kcenon::pacs::web::metadata_request::tags.

Here is the call graph for this function:

◆ get_navigation()

navigation_info kcenon::pacs::web::metadata_service::get_navigation ( std::string_view sop_instance_uid )

nodiscard

Get navigation info for an instance.

Parameters

sop_instance_uid SOP Instance UID

Returns: Navigation info with previous/next instance UIDs

Definition at line 480 of file metadata_service.cpp.

                                     {
    if (database_ == nullptr) {
        return navigation_info::error("Database not configured");
    }
 
    // Get series UID for this instance
    auto series_uid_opt = get_series_uid(sop_instance_uid);
    if (!series_uid_opt.has_value()) {
        return navigation_info::error("Instance not found");
    }
 
    // Get sorted instances
    auto sorted_result =
        get_sorted_instances(series_uid_opt.value(), sort_order::position, true);
    if (!sorted_result.success) {
        return navigation_info::error(sorted_result.error_message);
    }
 
    const auto& instances = sorted_result.instances;
    if (instances.empty()) {
        return navigation_info::error("Series is empty");
    }
 
    // Find current instance index
    size_t current_index = 0;
    bool found = false;
    for (size_t i = 0; i < instances.size(); ++i) {
        if (instances[i].sop_instance_uid == sop_instance_uid) {
            current_index = i;
            found = true;
            break;
        }
    }
 
    if (!found) {
        return navigation_info::error("Instance not found in series");
    }
 
    // Build navigation info
    navigation_info nav = navigation_info::ok();
    nav.index = current_index;
    nav.total = instances.size();
    nav.first = instances.front().sop_instance_uid;
    nav.last = instances.back().sop_instance_uid;
 
    if (current_index > 0) {
        nav.previous = instances[current_index - 1].sop_instance_uid;
    }
 
    if (current_index < instances.size() - 1) {
        nav.next = instances[current_index + 1].sop_instance_uid;
    }
 
    return nav;
}

References database_, kcenon::pacs::web::navigation_info::error(), kcenon::pacs::web::navigation_info::first, get_series_uid(), get_sorted_instances(), kcenon::pacs::web::navigation_info::index, kcenon::pacs::web::navigation_info::last, kcenon::pacs::web::navigation_info::next, kcenon::pacs::web::navigation_info::ok(), kcenon::pacs::web::position, kcenon::pacs::web::navigation_info::previous, and kcenon::pacs::web::navigation_info::total.

Here is the call graph for this function:

◆ get_preset_tags()

std::unordered_set< std::string > kcenon::pacs::web::metadata_service::get_preset_tags ( metadata_preset preset )

staticnodiscard

Get tags for a specific preset.

Parameters

preset The metadata preset

Returns: Set of DICOM tags (hex format) for the preset

Definition at line 182 of file metadata_service.cpp.

                            {
    using namespace kcenon::pacs::core::tags;
 
    std::unordered_set<std::string> tags;
 
    switch (preset) {
        case metadata_preset::image_display:
            // Rows, Columns, BitsAllocated, BitsStored, HighBit,
            // PixelRepresentation, PhotometricInterpretation, SamplesPerPixel
            tags.insert(tag_to_hex(rows));
            tags.insert(tag_to_hex(columns));
            tags.insert(tag_to_hex(bits_allocated));
            tags.insert(tag_to_hex(bits_stored));
            tags.insert(tag_to_hex(high_bit));
            tags.insert(tag_to_hex(pixel_representation));
            tags.insert(tag_to_hex(photometric_interpretation));
            tags.insert(tag_to_hex(samples_per_pixel));
            break;
 
        case metadata_preset::window_level:
            // WindowCenter, WindowWidth, RescaleSlope, RescaleIntercept
            tags.insert(tag_to_hex(window_center));
            tags.insert(tag_to_hex(window_width));
            tags.insert(tag_to_hex(rescale_slope));
            tags.insert(tag_to_hex(rescale_intercept));
            // Window Explanation (0028,1055)
            tags.insert("00281055");
            // VOI LUT Sequence (0028,3010)
            tags.insert("00283010");
            break;
 
        case metadata_preset::patient_info:
            // PatientName, PatientID, PatientBirthDate, PatientSex, PatientAge
            tags.insert(tag_to_hex(patient_name));
            tags.insert(tag_to_hex(patient_id));
            tags.insert(tag_to_hex(patient_birth_date));
            tags.insert(tag_to_hex(patient_sex));
            tags.insert(tag_to_hex(patient_age));
            break;
 
        case metadata_preset::acquisition:
            // KVP (0018,0060), ExposureTime (0018,1150), XRayTubeCurrent
            // (0018,1151) SliceThickness (0018,0050), SpacingBetweenSlices
            // (0018,0088)
            tags.insert("00180060");  // KVP
            tags.insert("00181150");  // ExposureTime
            tags.insert("00181151");  // XRayTubeCurrent
            tags.insert("00180050");  // SliceThickness
            tags.insert("00180088");  // SpacingBetweenSlices
            break;
 
        case metadata_preset::positioning:
            // ImagePositionPatient, ImageOrientationPatient, SliceLocation,
            // PixelSpacing
            tags.insert(tag_to_hex(image_position_patient));
            tags.insert(tag_to_hex(image_orientation_patient));
            tags.insert(tag_to_hex(slice_location));
            tags.insert(tag_to_hex(pixel_spacing));
            break;
 
        case metadata_preset::multiframe:
            // NumberOfFrames (0028,0008), FrameIncrementPointer (0028,0009),
            // FrameTime (0018,1063)
            tags.insert("00280008");  // NumberOfFrames
            tags.insert("00280009");  // FrameIncrementPointer
            tags.insert("00181063");  // FrameTime
            break;
    }
 
    return tags;
}

References kcenon::pacs::web::acquisition, kcenon::pacs::web::image_display, kcenon::pacs::web::multiframe, kcenon::pacs::web::patient_info, kcenon::pacs::web::positioning, and kcenon::pacs::web::window_level.

Referenced by get_metadata().

Here is the caller graph for this function:

◆ get_series_uid()

std::optional< std::string > kcenon::pacs::web::metadata_service::get_series_uid ( std::string_view sop_instance_uid )

nodiscardprivate

Get series UID for an instance.

Parameters

sop_instance_uid SOP Instance UID

Returns: Series UID if found

Definition at line 348 of file metadata_service.cpp.

                                     {
    if (database_ == nullptr) {
        return std::nullopt;
    }
 
    auto instance = database_->find_instance(sop_instance_uid);
    if (!instance) {
        return std::nullopt;
    }
 
    // Get series from series_pk
    auto series = database_->find_series_by_pk(instance->series_pk);
    if (!series) {
        return std::nullopt;
    }
 
    return series->series_uid;
}

References database_.

Referenced by get_navigation().

Here is the caller graph for this function:

◆ get_sorted_instances()

sorted_instances_response kcenon::pacs::web::metadata_service::get_sorted_instances	(	std::string_view	series_uid,
		sort_order	order = sort_order::position,
		bool	ascending = true )

nodiscard

Get sorted instances for a series.

Parameters

series_uid	Series Instance UID
order	Sort order
ascending	Sort direction

Returns: Sorted instances response

Definition at line 368 of file metadata_service.cpp.

                                                                 {
    if (database_ == nullptr) {
        return sorted_instances_response::error("Database not configured");
    }
 
    // Get all instances in the series
    auto instances_result = database_->list_instances(series_uid);
    if (instances_result.is_err()) {
        return sorted_instances_response::error("Failed to list instances");
    }
 
    auto& instances = instances_result.value();
    if (instances.empty()) {
        return sorted_instances_response::error("Series not found or empty");
    }
 
    // Build sorted_instance list with additional DICOM metadata
    std::vector<sorted_instance> sorted;
    sorted.reserve(instances.size());
 
    for (const auto& inst : instances) {
        sorted_instance si;
        si.sop_instance_uid = inst.sop_uid;
        si.instance_number = inst.instance_number;
 
        // Read additional positioning data from DICOM file if exists
        if (std::filesystem::exists(inst.file_path)) {
            auto file_result =
                kcenon::pacs::core::dicom_file::open(std::filesystem::path(inst.file_path));
            if (file_result.is_ok()) {
                const auto& ds = file_result.value().dataset();
 
                // Slice location
                auto slice_str = ds.get_string(kcenon::pacs::core::tags::slice_location);
                if (!slice_str.empty()) {
                    try {
                        si.slice_location = std::stod(slice_str);
                    } catch (...) {
                    }
                }
 
                // Image position patient
                auto pos_str =
                    ds.get_string(kcenon::pacs::core::tags::image_position_patient);
                if (!pos_str.empty()) {
                    si.image_position_patient = parse_numeric_list(pos_str);
                }
 
                // Acquisition time
                auto time_str = ds.get_string(kcenon::pacs::core::tags::acquisition_time);
                if (!time_str.empty()) {
                    si.acquisition_time = time_str;
                }
            }
        }
 
        sorted.push_back(std::move(si));
    }
 
    // Sort based on order
    auto compare = [order, ascending](const sorted_instance& a,
                                       const sorted_instance& b) {
        bool result = false;
 
        switch (order) {
            case sort_order::position: {
                // Sort by slice location or Z position
                double a_pos = 0.0;
                double b_pos = 0.0;
 
                if (a.slice_location.has_value()) {
                    a_pos = a.slice_location.value();
                } else if (a.image_position_patient.has_value() &&
                           a.image_position_patient->size() >= 3) {
                    a_pos = (*a.image_position_patient)[2];  // Z position
                }
 
                if (b.slice_location.has_value()) {
                    b_pos = b.slice_location.value();
                } else if (b.image_position_patient.has_value() &&
                           b.image_position_patient->size() >= 3) {
                    b_pos = (*b.image_position_patient)[2];
                }
 
                result = a_pos < b_pos;
                break;
            }
 
            case sort_order::instance_number: {
                int a_num = a.instance_number.value_or(0);
                int b_num = b.instance_number.value_or(0);
                result = a_num < b_num;
                break;
            }
 
            case sort_order::acquisition_time: {
                std::string a_time = a.acquisition_time.value_or("");
                std::string b_time = b.acquisition_time.value_or("");
                result = a_time < b_time;
                break;
            }
        }
 
        return ascending ? result : !result;
    };
 
    std::sort(sorted.begin(), sorted.end(), compare);
 
    return sorted_instances_response::ok(std::move(sorted), instances.size());
}

Referenced by get_navigation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_voi_lut()

voi_lut_info kcenon::pacs::web::metadata_service::get_voi_lut ( std::string_view sop_instance_uid )

nodiscard

Get VOI LUT info from an instance.

Parameters

sop_instance_uid SOP Instance UID

Returns: VOI LUT information

Definition at line 570 of file metadata_service.cpp.

                                                                          {
    if (database_ == nullptr) {
        return voi_lut_info::error("Database not configured");
    }
 
    auto instance = database_->find_instance(sop_instance_uid);
    if (!instance) {
        return voi_lut_info::error("Instance not found");
    }
 
    if (!std::filesystem::exists(instance->file_path)) {
        return voi_lut_info::error("DICOM file not found");
    }
 
    auto file_result =
        kcenon::pacs::core::dicom_file::open(std::filesystem::path(instance->file_path));
    if (file_result.is_err()) {
        return voi_lut_info::error("Failed to open DICOM file");
    }
 
    const auto& ds = file_result.value().dataset();
 
    voi_lut_info info = voi_lut_info::ok();
 
    // Window Center
    auto wc_str = ds.get_string(kcenon::pacs::core::tags::window_center);
    if (!wc_str.empty()) {
        info.window_center = parse_numeric_list(wc_str);
    }
 
    // Window Width
    auto ww_str = ds.get_string(kcenon::pacs::core::tags::window_width);
    if (!ww_str.empty()) {
        info.window_width = parse_numeric_list(ww_str);
    }
 
    // Window Explanation (0028,1055)
    const auto* we_elem =
        ds.get(kcenon::pacs::core::dicom_tag{0x0028, 0x1055});
    if (we_elem != nullptr) {
        auto we_result = we_elem->as_string();
        if (we_result.is_ok()) {
            info.window_explanations = parse_string_list(we_result.value());
        }
    }
 
    // Rescale Slope
    auto rs_str = ds.get_string(kcenon::pacs::core::tags::rescale_slope);
    if (!rs_str.empty()) {
        try {
            info.rescale_slope = std::stod(rs_str);
        } catch (...) {
        }
    }
 
    // Rescale Intercept
    auto ri_str = ds.get_string(kcenon::pacs::core::tags::rescale_intercept);
    if (!ri_str.empty()) {
        try {
            info.rescale_intercept = std::stod(ri_str);
        } catch (...) {
        }
    }
 
    return info;
}

References database_, kcenon::pacs::web::voi_lut_info::error(), kcenon::pacs::web::voi_lut_info::ok(), kcenon::pacs::core::dicom_file::open(), kcenon::pacs::core::tags::rescale_intercept, kcenon::pacs::core::tags::rescale_slope, kcenon::pacs::core::tags::window_center, and kcenon::pacs::core::tags::window_width.

Here is the call graph for this function:

◆ get_window_level_presets()

std::vector< window_level_preset > kcenon::pacs::web::metadata_service::get_window_level_presets ( std::string_view modality )

staticnodiscard

Get window/level presets for a modality.

Parameters

modality Modality code (CT, MR, etc.)

Returns: Vector of window/level presets

Definition at line 541 of file metadata_service.cpp.

                             {
    std::vector<window_level_preset> presets;
 
    if (modality == "CT") {
        presets.push_back({"Lung", -600, 1500});
        presets.push_back({"Bone", 300, 1500});
        presets.push_back({"Soft Tissue", 40, 400});
        presets.push_back({"Brain", 40, 80});
        presets.push_back({"Liver", 60, 150});
        presets.push_back({"Mediastinum", 50, 350});
    } else if (modality == "MR") {
        presets.push_back({"T1 Brain", 600, 1200});
        presets.push_back({"T2 Brain", 700, 1400});
        presets.push_back({"Spine", 500, 1000});
    } else if (modality == "CR" || modality == "DX") {
        presets.push_back({"Default", 2048, 4096});
        presets.push_back({"Bone", 1500, 3000});
        presets.push_back({"Soft Tissue", 1800, 3600});
    } else if (modality == "US") {
        presets.push_back({"Default", 128, 256});
    } else {
        // Generic presets
        presets.push_back({"Default", 128, 256});
    }
 
    return presets;
}

Referenced by kcenon::pacs::web::endpoints::register_metadata_endpoints_impl().

Here is the caller graph for this function:

◆ operator=() [1/2]

metadata_service & kcenon::pacs::web::metadata_service::operator= ( const metadata_service & )

delete

◆ operator=() [2/2]

metadata_service & kcenon::pacs::web::metadata_service::operator= ( metadata_service && )

delete

◆ read_dicom_tags()

std::unordered_map< std::string, std::string > kcenon::pacs::web::metadata_service::read_dicom_tags	(	std::string_view	file_path,
		const std::unordered_set< std::string > &	requested_tags,
		bool	include_private )

nodiscardprivate

Read DICOM dataset from file.

Parameters

file_path Path to DICOM file

Returns: Map of tag values

Definition at line 303 of file metadata_service.cpp.

                          {
    std::unordered_map<std::string, std::string> result;
 
    // Open DICOM file
    auto file_result = kcenon::pacs::core::dicom_file::open(std::filesystem::path(file_path));
    if (file_result.is_err()) {
        return result;  // Return empty map on failure
    }
 
    const auto& dataset = file_result.value().dataset();
 
    // Convert requested tags to dicom_tag and extract values
    for (const auto& tag_hex : requested_tags) {
        auto tag_opt = hex_to_tag(tag_hex);
        if (!tag_opt.has_value()) {
            continue;
        }
 
        auto tag = tag_opt.value();
 
        // Skip private tags if not requested
        if (tag.is_private() && !include_private) {
            continue;
        }
 
        // Get element value
        const auto* elem = dataset.get(tag);
        if (elem != nullptr) {
            auto str_result = elem->as_string();
            if (str_result.is_ok()) {
                result[tag_hex] = str_result.value();
            }
        }
    }
 
    return result;
}

References kcenon::pacs::core::dicom_tag::is_private(), and kcenon::pacs::core::dicom_file::open().

Referenced by get_metadata().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ database_

std::shared_ptr<storage::index_database> kcenon::pacs::web::metadata_service::database_

private

Database for instance lookups.

Definition at line 440 of file metadata_service.h.

Referenced by get_frame_info(), get_metadata(), get_navigation(), get_series_uid(), get_sorted_instances(), and get_voi_lut().

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

include/kcenon/pacs/web/metadata_service.h
src/web/metadata_service.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ metadata_service() [1/3]

◆ ~metadata_service()

◆ metadata_service() [2/3]

◆ metadata_service() [3/3]

Member Function Documentation

◆ get_frame_info()

◆ get_metadata()

◆ get_navigation()

◆ get_preset_tags()

◆ get_series_uid()

◆ get_sorted_instances()

◆ get_voi_lut()

◆ get_window_level_presets()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ read_dicom_tags()

Member Data Documentation

◆ database_