metadata_service.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace kcenon::pacs::storage {
class index_database;
}  // namespace kcenon::pacs::storage
 
namespace kcenon::pacs::web {
 
enum class metadata_preset {
    image_display,   
    window_level,    
    patient_info,    
    acquisition,     
    positioning,     
    multiframe       
};
 
[[nodiscard]] std::string_view preset_to_string(metadata_preset preset);
 
[[nodiscard]] std::optional<metadata_preset> preset_from_string(
    std::string_view str);
 
struct metadata_request {
    std::vector<std::string> tags;
 
    std::optional<metadata_preset> preset;
 
    bool include_private{false};
};
 
struct tag_value {
    std::string tag;
 
    std::string value;
 
    bool is_array{false};
};
 
struct metadata_response {
    bool success{false};
 
    std::string error_message;
 
    std::unordered_map<std::string, std::string> tags;
 
    static metadata_response ok(
        std::unordered_map<std::string, std::string> tag_map) {
        metadata_response r;
        r.success = true;
        r.tags = std::move(tag_map);
        return r;
    }
 
    static metadata_response error(std::string message) {
        metadata_response r;
        r.success = false;
        r.error_message = std::move(message);
        return r;
    }
};
 
struct sorted_instance {
    std::string sop_instance_uid;
 
    std::optional<int> instance_number;
 
    std::optional<double> slice_location;
 
    std::optional<std::vector<double>> image_position_patient;
 
    std::optional<std::string> acquisition_time;
};
 
enum class sort_order {
    position,         
    instance_number,  
    acquisition_time  
};
 
[[nodiscard]] std::string_view sort_order_to_string(sort_order order);
 
[[nodiscard]] std::optional<sort_order> sort_order_from_string(
    std::string_view str);
 
struct sorted_instances_response {
    bool success{false};
 
    std::string error_message;
 
    std::vector<sorted_instance> instances;
 
    size_t total{0};
 
    static sorted_instances_response ok(std::vector<sorted_instance> inst,
                                         size_t count) {
        sorted_instances_response r;
        r.success = true;
        r.instances = std::move(inst);
        r.total = count;
        return r;
    }
 
    static sorted_instances_response error(std::string message) {
        sorted_instances_response r;
        r.success = false;
        r.error_message = std::move(message);
        return r;
    }
};
 
struct navigation_info {
    bool success{false};
 
    std::string error_message;
 
    std::string previous;
 
    std::string next;
 
    size_t index{0};
 
    size_t total{0};
 
    std::string first;
 
    std::string last;
 
    static navigation_info ok() {
        navigation_info r;
        r.success = true;
        return r;
    }
 
    static navigation_info error(std::string message) {
        navigation_info r;
        r.success = false;
        r.error_message = std::move(message);
        return r;
    }
};
 
struct window_level_preset {
    std::string name;
 
    double center;
 
    double width;
};
 
struct voi_lut_info {
    bool success{false};
 
    std::string error_message;
 
    std::vector<double> window_center;
 
    std::vector<double> window_width;
 
    std::vector<std::string> window_explanations;
 
    double rescale_slope{1.0};
 
    double rescale_intercept{0.0};
 
    static voi_lut_info ok() {
        voi_lut_info r;
        r.success = true;
        return r;
    }
 
    static voi_lut_info error(std::string message) {
        voi_lut_info r;
        r.success = false;
        r.error_message = std::move(message);
        return r;
    }
};
 
struct frame_info {
    bool success{false};
 
    std::string error_message;
 
    uint32_t total_frames{1};
 
    std::optional<double> frame_time;
 
    std::optional<double> frame_rate;
 
    uint16_t rows{0};
 
    uint16_t columns{0};
 
    static frame_info ok() {
        frame_info r;
        r.success = true;
        return r;
    }
 
    static frame_info error(std::string message) {
        frame_info r;
        r.success = false;
        r.error_message = std::move(message);
        return r;
    }
};
 
class metadata_service {
public:
    explicit metadata_service(
        std::shared_ptr<storage::index_database> database);
 
    ~metadata_service();
 
    metadata_service(const metadata_service&) = delete;
    metadata_service& operator=(const metadata_service&) = delete;
    metadata_service(metadata_service&&) = delete;
    metadata_service& operator=(metadata_service&&) = delete;
 
    // =========================================================================
    // Selective Metadata Retrieval
    // =========================================================================
 
    [[nodiscard]] metadata_response get_metadata(
        std::string_view sop_instance_uid,
        const metadata_request& request);
 
    [[nodiscard]] static std::unordered_set<std::string> get_preset_tags(
        metadata_preset preset);
 
    // =========================================================================
    // Series Navigation
    // =========================================================================
 
    [[nodiscard]] sorted_instances_response get_sorted_instances(
        std::string_view series_uid,
        sort_order order = sort_order::position,
        bool ascending = true);
 
    [[nodiscard]] navigation_info get_navigation(
        std::string_view sop_instance_uid);
 
    // =========================================================================
    // Window/Level Presets
    // =========================================================================
 
    [[nodiscard]] static std::vector<window_level_preset>
    get_window_level_presets(std::string_view modality);
 
    [[nodiscard]] voi_lut_info get_voi_lut(std::string_view sop_instance_uid);
 
    // =========================================================================
    // Multi-frame Support
    // =========================================================================
 
    [[nodiscard]] frame_info get_frame_info(std::string_view sop_instance_uid);
 
private:
    std::shared_ptr<storage::index_database> database_;
 
    [[nodiscard]] 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);
 
    [[nodiscard]] std::optional<std::string> get_series_uid(
        std::string_view sop_instance_uid);
};
 
}  // namespace kcenon::pacs::web