Collaboration diagram for kcenon::pacs::ai::ai_result_handler::impl:

Public Member Functions
	impl (std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< storage::index_database > database)

auto	validate_common_tags (const core::dicom_dataset &dataset) -> validation_result

auto	validate_source_references_exist (const core::dicom_dataset &dataset) -> validation_result

auto	store_ai_result (const core::dicom_dataset &dataset, ai_result_type type) -> VoidResult

Public Attributes
ai_handler_config	config_

ai_result_received_callback	received_callback_

pre_store_validator	pre_store_validator_

std::shared_ptr< storage::storage_interface >	storage_

std::shared_ptr< storage::index_database >	database_

std::map< std::string, ai_result_info >	ai_results_cache_

std::map< std::string, source_reference >	source_links_

Detailed Description

Definition at line 107 of file ai_result_handler.cpp.

Constructor & Destructor Documentation

◆ impl()

kcenon::pacs::ai::ai_result_handler::impl::impl	(	std::shared_ptr< storage::storage_interface >	storage,
		std::shared_ptr< storage::index_database >	database )

inline

Definition at line 109 of file ai_result_handler.cpp.

111 : storage_(std::move(storage))

112 , database_(std::move(database)) {}

kcenon::pacs::ai::ai_result_handler::impl::database_

std::shared_ptr< storage::index_database > database_

Definition ai_result_handler.cpp:123

kcenon::pacs::ai::ai_result_handler::impl::storage_

std::shared_ptr< storage::storage_interface > storage_

Definition ai_result_handler.cpp:122

Member Function Documentation

◆ store_ai_result()

auto kcenon::pacs::ai::ai_result_handler::impl::store_ai_result	(	const core::dicom_dataset &	dataset,
		ai_result_type	type ) -> VoidResult

inlinenodiscard

Definition at line 192 of file ai_result_handler.cpp.

                                           {
        // Store the dataset
        auto store_result = storage_->store(dataset);
        if (store_result.is_err()) {
            return store_result;
        }
 
        // Extract metadata for caching
        auto sop_instance_uid = dataset.get_string(core::tags::sop_instance_uid);
        auto [algo_name, algo_version] = extract_algorithm_info(dataset);
 
        ai_result_info info;
        info.sop_instance_uid = sop_instance_uid;
        info.type = type;
        info.sop_class_uid = dataset.get_string(core::tags::sop_class_uid);
        info.series_instance_uid = dataset.get_string(core::tags::series_instance_uid);
        info.source_study_uid = dataset.get_string(core::tags::study_instance_uid);
        info.algorithm_name = algo_name;
        info.algorithm_version = algo_version;
        info.received_at = std::chrono::system_clock::now();
 
        // Cache the result info
        ai_results_cache_[sop_instance_uid] = info;
 
        // Auto-link to source if configured
        if (config_.auto_link_to_source && !info.source_study_uid.empty()) {
            source_reference ref;
            ref.study_instance_uid = info.source_study_uid;
            source_links_[sop_instance_uid] = ref;
        }
 
        // Call notification callback
        if (received_callback_) {
            received_callback_(info);
        }
 
        return ok();
    }

References ai_results_cache_, kcenon::pacs::ai::ai_handler_config::auto_link_to_source, config_, received_callback_, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, source_links_, storage_, kcenon::pacs::ai::source_reference::study_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

◆ validate_common_tags()

auto kcenon::pacs::ai::ai_result_handler::impl::validate_common_tags ( const core::dicom_dataset & dataset ) -> validation_result

inlinenodiscard

Definition at line 135 of file ai_result_handler.cpp.

                             {
        validation_result result;
        result.status = validation_status::valid;
 
        // Check required DICOM tags
        std::vector<std::pair<core::dicom_tag, std::string>> required_tags = {
            {core::tags::sop_class_uid, "SOP Class UID"},
            {core::tags::sop_instance_uid, "SOP Instance UID"},
            {core::tags::study_instance_uid, "Study Instance UID"},
            {core::tags::series_instance_uid, "Series Instance UID"},
            {core::tags::modality, "Modality"}
        };
 
        for (const auto& [tag, name] : required_tags) {
            if (dataset.get_string(tag).empty()) {
                result.missing_tags.push_back(name);
            }
        }
 
        if (!result.missing_tags.empty()) {
            result.status = validation_status::missing_required_tags;
            result.error_message = "Missing required DICOM tags";
        }
 
        return result;
    }

References kcenon::pacs::ai::validation_result::error_message, kcenon::pacs::ai::missing_required_tags, kcenon::pacs::ai::validation_result::missing_tags, kcenon::pacs::core::tags::modality, name, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, kcenon::pacs::ai::validation_result::status, kcenon::pacs::core::tags::study_instance_uid, and kcenon::pacs::ai::valid.

◆ validate_source_references_exist()

auto kcenon::pacs::ai::ai_result_handler::impl::validate_source_references_exist ( const core::dicom_dataset & dataset ) -> validation_result

inlinenodiscard

Definition at line 163 of file ai_result_handler.cpp.

                                                               {
        validation_result result;
        result.status = validation_status::valid;
 
        if (!config_.validate_source_references) {
            return result;
        }
 
        // Get Study Instance UID
        auto study_uid = dataset.get_string(core::tags::study_instance_uid);
        if (study_uid.empty()) {
            result.status = validation_status::invalid_reference;
            result.error_message = "Missing Study Instance UID for reference validation";
            return result;
        }
 
        // Check if the study exists in the database
        // Note: This would require a study lookup method in index_database
        // For now, we just validate the UID format
        if (study_uid.length() < 10) {  // Basic UID validation
            result.status = validation_status::invalid_reference;
            result.invalid_references.push_back(study_uid);
            result.error_message = "Invalid Study Instance UID format";
        }
 
        return result;
    }