imaging_document_source.cpp

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.
 
#include "kcenon/pacs/services/xds/imaging_document_source.h"
#include "kcenon/pacs/core/dicom_tag_constants.h"
#include "kcenon/pacs/encoding/vr_type.h"
#include "kcenon/pacs/security/atna_service_auditor.h"
#include "kcenon/pacs/services/sop_classes/sr_storage.h"
 
#include <algorithm>
#include <chrono>
#include <random>
#include <sstream>
#include <unordered_map>
 
namespace kcenon::pacs::services::xds {
 
using namespace kcenon::pacs::core;
using namespace kcenon::pacs::encoding;
 
// =============================================================================
// KOS-specific DICOM Tags
// =============================================================================
 
namespace kos_tags {
 
constexpr dicom_tag value_type{0x0040, 0xA040};
constexpr dicom_tag concept_name_code_sequence{0x0040, 0xA043};
constexpr dicom_tag content_template_sequence{0x0040, 0xA504};
constexpr dicom_tag template_identifier{0x0040, 0xDB00};
constexpr dicom_tag mapping_resource{0x0008, 0x0105};
constexpr dicom_tag current_requested_procedure_evidence_sequence{0x0040, 0xA375};
constexpr dicom_tag referenced_series_sequence{0x0008, 0x1115};
constexpr dicom_tag referenced_sop_sequence{0x0008, 0x1199};
constexpr dicom_tag referenced_sop_class_uid{0x0008, 0x1150};
constexpr dicom_tag referenced_sop_instance_uid{0x0008, 0x1155};
constexpr dicom_tag code_value{0x0008, 0x0100};
constexpr dicom_tag coding_scheme_designator{0x0008, 0x0102};
constexpr dicom_tag code_meaning{0x0008, 0x0104};
constexpr dicom_tag completion_flag{0x0040, 0xA491};
constexpr dicom_tag verification_flag{0x0040, 0xA493};
 
}  // namespace kos_tags
 
// =============================================================================
// Helper: insert a sequence element into a dataset
// =============================================================================
 
namespace {
 
void insert_sequence(dicom_dataset& ds, dicom_tag tag,
                     std::vector<dicom_dataset> items) {
    dicom_element seq_elem(tag, vr_type::SQ);
    seq_elem.sequence_items() = std::move(items);
    ds.insert(std::move(seq_elem));
}
 
std::string current_datetime() {
    auto now = std::chrono::system_clock::now();
    auto time_t_now = std::chrono::system_clock::to_time_t(now);
    std::tm tm_now{};
#if defined(_WIN32)
    gmtime_s(&tm_now, &time_t_now);
#else
    gmtime_r(&time_t_now, &tm_now);
#endif
    char buf[16];
    std::strftime(buf, sizeof(buf), "%Y%m%d%H%M%S", &tm_now);
    return buf;
}
 
std::string current_date() {
    return current_datetime().substr(0, 8);
}
 
std::string current_time() {
    return current_datetime().substr(8, 6);
}
 
}  // namespace
 
// =============================================================================
// imaging_document_source Implementation
// =============================================================================
 
imaging_document_source::imaging_document_source(
    const imaging_document_source_config& config)
    : config_(config) {}
 
kos_creation_result imaging_document_source::create_kos_document(
    const std::string& study_instance_uid,
    const std::vector<kos_instance_reference>& references,
    const std::optional<core::dicom_dataset>& patient_demographics) const {
 
    kos_creation_result result;
 
    if (references.empty()) {
        result.error_message = "No instance references provided";
        return result;
    }
 
    core::dicom_dataset kos;
 
    // --- SOP Common Module ---
    kos.set_string(tags::sop_class_uid, vr_type::UI,
                   std::string(sop_classes::key_object_selection_document_storage_uid));
    result.kos_instance_uid = generate_uid();
    kos.set_string(tags::sop_instance_uid, vr_type::UI, result.kos_instance_uid);
 
    // --- Patient Module (Type 2) ---
    if (patient_demographics) {
        auto copy_if_present = [&](dicom_tag tag, vr_type vr) {
            if (patient_demographics->contains(tag)) {
                kos.set_string(tag, vr, patient_demographics->get_string(tag));
            } else {
                kos.set_string(tag, vr, "");
            }
        };
        copy_if_present(tags::patient_name, vr_type::PN);
        copy_if_present(tags::patient_id, vr_type::LO);
        copy_if_present(tags::patient_birth_date, vr_type::DA);
        copy_if_present(tags::patient_sex, vr_type::CS);
    } else {
        kos.set_string(tags::patient_name, vr_type::PN, "");
        kos.set_string(tags::patient_id, vr_type::LO, "");
        kos.set_string(tags::patient_birth_date, vr_type::DA, "");
        kos.set_string(tags::patient_sex, vr_type::CS, "");
    }
 
    // --- General Study Module ---
    kos.set_string(tags::study_instance_uid, vr_type::UI, study_instance_uid);
    kos.set_string(tags::study_date, vr_type::DA, current_date());
    kos.set_string(tags::study_time, vr_type::TM, current_time());
    kos.set_string(tags::referring_physician_name, vr_type::PN, "");
    kos.set_string(tags::study_id, vr_type::SH, "");
    kos.set_string(tags::accession_number, vr_type::SH, "");
 
    // --- General Series Module ---
    kos.set_string(tags::modality, vr_type::CS, "KO");
    kos.set_string(tags::series_instance_uid, vr_type::UI, generate_uid());
    kos.set_string(tags::series_number, vr_type::IS, "1");
 
    // --- General Equipment Module ---
    kos.set_string(dicom_tag{0x0008, 0x0070}, vr_type::LO, "");  // Manufacturer
 
    // --- SR Document General Module ---
    kos.set_string(tags::instance_number, vr_type::IS, "1");
    kos.set_string(tags::content_date, vr_type::DA, current_date());
    kos.set_string(tags::content_time, vr_type::TM, current_time());
    kos.set_string(kos_tags::completion_flag, vr_type::CS, "COMPLETE");
    kos.set_string(kos_tags::verification_flag, vr_type::CS, "UNVERIFIED");
 
    // --- SR Document Content Module ---
    // Value type: CONTAINER (root)
    kos.set_string(kos_tags::value_type, vr_type::CS, "CONTAINER");
 
    // Concept Name Code Sequence: Key Object Selection (113000, DCM)
    dicom_dataset concept_name;
    concept_name.set_string(kos_tags::code_value, vr_type::SH, "113000");
    concept_name.set_string(kos_tags::coding_scheme_designator, vr_type::SH, "DCM");
    concept_name.set_string(kos_tags::code_meaning, vr_type::LO, "Of Interest");
    insert_sequence(kos, kos_tags::concept_name_code_sequence, {concept_name});
 
    // Content Template Sequence: TID 2010
    dicom_dataset template_item;
    template_item.set_string(kos_tags::template_identifier, vr_type::CS, "2010");
    template_item.set_string(kos_tags::mapping_resource, vr_type::CS, "DCMR");
    insert_sequence(kos, kos_tags::content_template_sequence, {template_item});
 
    // --- Current Requested Procedure Evidence Sequence ---
    build_evidence_sequence(kos, references);
 
    result.success = true;
    result.reference_count = references.size();
    result.kos_dataset = std::move(kos);
 
    return result;
}
 
xds_document_entry imaging_document_source::build_document_entry(
    const core::dicom_dataset& kos_dataset) const {
 
    xds_document_entry entry;
 
    entry.entry_uuid = "urn:uuid:" + generate_uid();
    entry.unique_id = kos_dataset.get_string(tags::sop_instance_uid);
    entry.patient_id = kos_dataset.get_string(tags::patient_id);
    entry.source_patient_id = entry.patient_id;
 
    entry.class_code = "IMG";
    entry.class_code_scheme = "1.3.6.1.4.1.19376.3.840.1.1.4";
    entry.class_code_display = "Imaging Procedure";
 
    entry.type_code = "KOS";
    entry.type_code_scheme = "1.2.840.10008.2.16.4";
    entry.type_code_display = "Key Object Selection";
 
    entry.format_code = std::string(sop_classes::key_object_selection_document_storage_uid);
    entry.format_code_scheme = "1.2.840.10008.2.6.1";
 
    entry.creation_time = current_datetime();
    entry.service_start_time = entry.creation_time;
    entry.service_stop_time = entry.creation_time;
 
    entry.facility_type_code = config_.facility_type_code;
    entry.facility_type_code_scheme = config_.facility_type_code_scheme;
    entry.practice_setting_code = config_.practice_setting_code;
    entry.practice_setting_code_scheme = config_.practice_setting_code_scheme;
 
    // Extract author from patient demographics if available
    auto ref_physician = kos_dataset.get_string(tags::referring_physician_name);
    if (!ref_physician.empty()) {
        entry.author_person = ref_physician;
    }
 
    entry.title = "Key Object Selection Document";
 
    return entry;
}
 
xds_submission_set imaging_document_source::build_submission_set(
    const std::string& patient_id) const {
 
    xds_submission_set set;
 
    set.unique_id = generate_uid();
    set.source_id = config_.source_oid;
    set.patient_id = patient_id;
    set.content_type_code = "IMG";
    set.content_type_code_scheme = "1.3.6.1.4.1.19376.3.840.1.1.4";
    set.content_type_code_display = "Imaging Procedure";
    set.submission_time = current_datetime();
 
    return set;
}
 
namespace {
 
std::vector<std::string> collect_sop_instance_uids(
    const core::dicom_dataset& kos_dataset) {
    std::vector<std::string> uids;
    const auto* evidence_elem =
        kos_dataset.get(kos_tags::current_requested_procedure_evidence_sequence);
    if (!evidence_elem || !evidence_elem->is_sequence()) {
        return uids;
    }
    for (const auto& study_item : evidence_elem->sequence_items()) {
        const auto* series_elem =
            study_item.get(kos_tags::referenced_series_sequence);
        if (!series_elem || !series_elem->is_sequence()) continue;
        for (const auto& series_item : series_elem->sequence_items()) {
            const auto* sop_elem =
                series_item.get(kos_tags::referenced_sop_sequence);
            if (!sop_elem || !sop_elem->is_sequence()) continue;
            for (const auto& sop_item : sop_elem->sequence_items()) {
                auto uid = sop_item.get_string(kos_tags::referenced_sop_instance_uid);
                if (!uid.empty()) uids.push_back(std::move(uid));
            }
        }
    }
    return uids;
}
 
}  // namespace
 
publication_result imaging_document_source::publish_document(
    const core::dicom_dataset& kos_dataset,
    const xds_document_entry& entry,
    bool is_imaging) const {
 
    publication_result result;
 
    // Build audit fields once; used for both success and failure paths.
    auto study_uid = kos_dataset.get_string(core::tags::study_instance_uid);
    auto patient_id = kos_dataset.get_string(core::tags::patient_id);
    auto sop_instance_uids = collect_sop_instance_uids(kos_dataset);
    const auto transaction =
        is_imaging
            ? security::atna_service_auditor::xds_source_transaction::rad_68
            : security::atna_service_auditor::xds_source_transaction::iti_41;
 
    if (config_.registry_url.empty()) {
        result.error_message = "XDS registry URL not configured";
        if (auditor_) {
            auditor_->audit_xds_provide_and_register(
                transaction,
                config_.source_oid,
                config_.registry_url,   // empty when unconfigured
                study_uid,
                patient_id,
                sop_instance_uids,
                false);
        }
        return result;
    }
 
    // NOTE: Actual HTTP POST to the XDS registry/repository (ITI-41 / RAD-68)
    // would be implemented here using the network layer.
    // The ITI-41 / RAD-68 transactions use SOAP/MTOM encoding.
    // For now, return success to indicate the interface is operational.
    result.success = true;
    result.document_entry_uuid = entry.entry_uuid;
 
    if (auditor_) {
        auditor_->audit_xds_provide_and_register(
            transaction,
            config_.source_oid,
            config_.registry_url,
            study_uid,
            patient_id,
            sop_instance_uids,
            true);
    }
 
    return result;
}
 
void imaging_document_source::set_audit_handler(
    std::shared_ptr<kcenon::pacs::security::atna_service_auditor> auditor) {
    auditor_ = std::move(auditor);
}
 
const imaging_document_source_config&
imaging_document_source::config() const noexcept {
    return config_;
}
 
void imaging_document_source::set_config(
    const imaging_document_source_config& config) {
    config_ = config;
}
 
std::string imaging_document_source::generate_uid() const {
    static constexpr const char* uid_root = "1.2.826.0.1.3680043.2.1545.1";
    static std::mt19937_64 gen{std::random_device{}()};
    static std::uniform_int_distribution<uint64_t> dist;
 
    auto now = std::chrono::system_clock::now();
    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count();
 
    return std::string(uid_root) + "." + std::to_string(timestamp) +
           "." + std::to_string(dist(gen) % 100000);
}
 
void imaging_document_source::build_evidence_sequence(
    core::dicom_dataset& kos_dataset,
    const std::vector<kos_instance_reference>& references) const {
 
    // Group references by study -> series -> instances
    struct series_group {
        std::string series_uid;
        std::vector<std::pair<std::string, std::string>> instances;  // sop_class, sop_instance
    };
 
    std::unordered_map<std::string, std::vector<series_group>> study_map;
 
    for (const auto& ref : references) {
        auto& series_list = study_map[ref.study_instance_uid];
 
        auto it = std::find_if(series_list.begin(), series_list.end(),
                               [&](const series_group& sg) {
                                   return sg.series_uid == ref.series_instance_uid;
                               });
 
        if (it != series_list.end()) {
            it->instances.emplace_back(ref.sop_class_uid, ref.sop_instance_uid);
        } else {
            series_group sg;
            sg.series_uid = ref.series_instance_uid;
            sg.instances.emplace_back(ref.sop_class_uid, ref.sop_instance_uid);
            series_list.push_back(std::move(sg));
        }
    }
 
    // Build the sequence structure
    std::vector<dicom_dataset> study_items;
    for (const auto& [study_uid, series_list] : study_map) {
        dicom_dataset study_item;
        study_item.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
 
        std::vector<dicom_dataset> series_items;
        for (const auto& sg : series_list) {
            dicom_dataset series_item;
            series_item.set_string(tags::series_instance_uid, vr_type::UI, sg.series_uid);
 
            std::vector<dicom_dataset> sop_items;
            for (const auto& [sop_class, sop_instance] : sg.instances) {
                dicom_dataset sop_item;
                sop_item.set_string(kos_tags::referenced_sop_class_uid, vr_type::UI, sop_class);
                sop_item.set_string(kos_tags::referenced_sop_instance_uid, vr_type::UI, sop_instance);
                sop_items.push_back(std::move(sop_item));
            }
            insert_sequence(series_item, kos_tags::referenced_sop_sequence, std::move(sop_items));
            series_items.push_back(std::move(series_item));
        }
        insert_sequence(study_item, kos_tags::referenced_series_sequence, std::move(series_items));
        study_items.push_back(std::move(study_item));
    }
 
    insert_sequence(kos_dataset,
                    kos_tags::current_requested_procedure_evidence_sequence,
                    std::move(study_items));
}
 
}  // namespace kcenon::pacs::services::xds