kcenon::pacs::ai::ai_result_handler Class Reference

#include <ai_result_handler.h>

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

Classes
class	impl

Public Member Functions
virtual	~ai_result_handler ()
	Destructor.
	ai_result_handler (const ai_result_handler &)=delete
auto	operator= (const ai_result_handler &) -> ai_result_handler &=delete
	ai_result_handler (ai_result_handler &&) noexcept
auto	operator= (ai_result_handler &&) noexcept -> ai_result_handler &
void	configure (const ai_handler_config &config)
	Configure handler behavior.
auto	get_config () const -> ai_handler_config
	Get current configuration.
void	set_received_callback (ai_result_received_callback callback)
	Set callback for AI result reception notifications.
void	set_pre_store_validator (pre_store_validator validator)
	Set custom pre-storage validator.
auto	receive_structured_report (const core::dicom_dataset &sr) -> VoidResult
	Receive and store an AI-generated Structured Report.
auto	validate_sr_template (const core::dicom_dataset &sr) -> validation_result
	Validate SR template conformance.
auto	get_cad_findings (std::string_view sr_sop_instance_uid) -> Result< std::vector< cad_finding > >
	Extract CAD findings from a Structured Report.
auto	receive_segmentation (const core::dicom_dataset &seg) -> VoidResult
	Receive and store an AI-generated Segmentation object.
auto	validate_segmentation (const core::dicom_dataset &seg) -> validation_result
	Validate segmentation data integrity.
auto	get_segment_info (std::string_view seg_sop_instance_uid) -> Result< std::vector< segment_info > >
	Get segment information from a stored Segmentation.
auto	receive_presentation_state (const core::dicom_dataset &pr) -> VoidResult
	Receive and store an AI-generated Presentation State.
auto	validate_presentation_state (const core::dicom_dataset &pr) -> validation_result
	Validate Presentation State.
auto	link_to_source (std::string_view result_uid, std::string_view source_study_uid) -> VoidResult
	Link an AI result to its source study.
auto	link_to_source (std::string_view result_uid, const source_reference &references) -> VoidResult
	Link an AI result with detailed source references.
auto	get_source_reference (std::string_view result_uid) -> Result< source_reference >
	Get source references for an AI result.
auto	find_ai_results_for_study (std::string_view study_instance_uid) -> Result< std::vector< ai_result_info > >
	Find all AI results linked to a study.
auto	find_ai_results_by_type (std::string_view study_instance_uid, ai_result_type type) -> Result< std::vector< ai_result_info > >
	Find AI results by type.
auto	get_ai_result_info (std::string_view sop_instance_uid) -> std::optional< ai_result_info >
	Get AI result information by SOP Instance UID.
auto	exists (std::string_view sop_instance_uid) const -> bool
	Check if an AI result exists.
auto	remove (std::string_view sop_instance_uid) -> VoidResult
	Remove an AI result and its source links.
auto	remove_ai_results_for_study (std::string_view study_instance_uid) -> Result< std::size_t >
	Remove all AI results linked to a study.

Static Public Member Functions
static auto	create (std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< storage::index_database > database) -> std::unique_ptr< ai_result_handler >
	Create an AI result handler.

Protected Member Functions
	ai_result_handler (std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< storage::index_database > database)
	Protected constructor - use create() factory method.

Private Attributes
std::unique_ptr< impl >	pimpl_

Detailed Description

Definition at line 259 of file ai_result_handler.h.

Constructor & Destructor Documentation

~ai_result_handler()

kcenon::pacs::ai::ai_result_handler::~ai_result_handler ( )

virtualdefault

Destructor.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

ai_result_handler() [1/3]

kcenon::pacs::ai::ai_result_handler::ai_result_handler ( const ai_result_handler & )

delete

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

ai_result_handler() [2/3]

kcenon::pacs::ai::ai_result_handler::ai_result_handler ( ai_result_handler && )

defaultnoexcept

ai_result_handler() [3/3]

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

protected

Protected constructor - use create() factory method.

Definition at line 246 of file ai_result_handler.cpp.

    : pimpl_(std::make_unique<impl>(std::move(storage), std::move(database))) {}

Member Function Documentation

configure()

void kcenon::pacs::ai::ai_result_handler::configure

(

const ai_handler_config &

config

)

Configure handler behavior.

Parameters

config

Configuration options

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 262 of file ai_result_handler.cpp.

                                                                 {
    pimpl_->config_ = config;
}

create()

auto kcenon::pacs::ai::ai_result_handler::create ( std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< storage::index_database > database ) -> std::unique_ptr<ai_result_handler>

staticnodiscard

Create an AI result handler.

Parameters

storage	Storage backend for persisting DICOM objects
database	Index database for metadata queries

Returns

Unique pointer to the handler instance

Definition at line 238 of file ai_result_handler.cpp.

                                        {
    return std::unique_ptr<ai_result_handler>(
        new ai_result_handler(std::move(storage), std::move(database)));
}

exists()

auto kcenon::pacs::ai::ai_result_handler::exists ( std::string_view sop_instance_uid ) const -> bool

nodiscard

Check if an AI result exists.

Parameters

sop_instance_uid

SOP Instance UID to check

Returns

true if the AI result exists, false otherwise

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 701 of file ai_result_handler.cpp.

                                                                            {
    // Check cache first
    if (pimpl_->ai_results_cache_.find(std::string(sop_instance_uid)) !=
        pimpl_->ai_results_cache_.end()) {
        return true;
    }
 
    // Check storage
    return pimpl_->storage_->exists(sop_instance_uid);
}

find_ai_results_by_type()

auto kcenon::pacs::ai::ai_result_handler::find_ai_results_by_type ( std::string_view study_instance_uid, ai_result_type type ) -> Result<std::vector<ai_result_info>>

nodiscard

Find AI results by type.

Parameters

study_instance_uid	Study Instance UID
type	Type of AI result to search for

Returns

Result containing list of AI result info or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 678 of file ai_result_handler.cpp.

                                                              {
    std::vector<ai_result_info> results;
 
    for (const auto& [uid, info] : pimpl_->ai_results_cache_) {
        if (info.source_study_uid == study_instance_uid && info.type == type) {
            results.push_back(info);
        }
    }
 
    return results;
}

References uid.

find_ai_results_for_study()

auto kcenon::pacs::ai::ai_result_handler::find_ai_results_for_study ( std::string_view study_instance_uid ) -> Result<std::vector<ai_result_info>>

nodiscard

Find all AI results linked to a study.

Parameters

study_instance_uid

Study Instance UID

Returns

Result containing list of AI result info or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 653 of file ai_result_handler.cpp.

                                         {
    std::vector<ai_result_info> results;
 
    for (const auto& [uid, info] : pimpl_->ai_results_cache_) {
        if (info.source_study_uid == study_instance_uid) {
            results.push_back(info);
        }
    }
 
    // Also check source links
    for (const auto& [uid, ref] : pimpl_->source_links_) {
        if (ref.study_instance_uid == study_instance_uid) {
            auto it = pimpl_->ai_results_cache_.find(uid);
            if (it != pimpl_->ai_results_cache_.end()) {
                // Already included from cache
                continue;
            }
            // Would need to retrieve from storage for complete info
        }
    }
 
    return results;
}

References uid.

get_ai_result_info()

auto kcenon::pacs::ai::ai_result_handler::get_ai_result_info ( std::string_view sop_instance_uid ) -> std::optional<ai_result_info>

nodiscard

Get AI result information by SOP Instance UID.

Parameters

sop_instance_uid

SOP Instance UID of the AI result

Returns

Optional containing AI result info if found

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 692 of file ai_result_handler.cpp.

                                   {
    auto it = pimpl_->ai_results_cache_.find(std::string(sop_instance_uid));
    if (it != pimpl_->ai_results_cache_.end()) {
        return it->second;
    }
    return std::nullopt;
}

get_cad_findings()

auto kcenon::pacs::ai::ai_result_handler::get_cad_findings ( std::string_view sr_sop_instance_uid ) -> Result<std::vector<cad_finding>>

nodiscard

Extract CAD findings from a Structured Report.

Parameters

sr_sop_instance_uid

SOP Instance UID of the SR

Returns

Result containing list of CAD findings or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 375 of file ai_result_handler.cpp.

                                      {
    // Retrieve the SR dataset
    auto retrieve_result = pimpl_->storage_->retrieve(sr_sop_instance_uid);
    if (retrieve_result.is_err()) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Failed to retrieve SR: " +
            std::string(sr_sop_instance_uid));
#else
        return std::string("Failed to retrieve SR: ") + std::string(sr_sop_instance_uid);
#endif
    }
 
    // Parse CAD findings from Content Sequence
    // This is a simplified implementation - full parsing would handle
    // the complete SR tree structure
    std::vector<cad_finding> findings;
 
    // Note: Actual implementation would parse the Content Sequence
    // recursively to extract CAD findings based on the SR template
 
    return findings;
}

get_config()

auto kcenon::pacs::ai::ai_result_handler::get_config ( ) const -> ai_handler_config

nodiscard

Get current configuration.

Returns

Current configuration

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 266 of file ai_result_handler.cpp.

                                                              {
    return pimpl_->config_;
}

References kcenon::pacs::ai::ai_result_handler::impl::config_, and pimpl_.

get_segment_info()

auto kcenon::pacs::ai::ai_result_handler::get_segment_info ( std::string_view seg_sop_instance_uid ) -> Result<std::vector<segment_info>>

nodiscard

Get segment information from a stored Segmentation.

Parameters

seg_sop_instance_uid

SOP Instance UID of the SEG

Returns

Result containing list of segment information or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 491 of file ai_result_handler.cpp.

                                       {
    // Retrieve the SEG dataset
    auto retrieve_result = pimpl_->storage_->retrieve(seg_sop_instance_uid);
    if (retrieve_result.is_err()) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Failed to retrieve SEG: " +
            std::string(seg_sop_instance_uid));
#else
        return std::string("Failed to retrieve SEG: ") + std::string(seg_sop_instance_uid);
#endif
    }
 
    // Parse segment information from Segment Sequence
    std::vector<segment_info> segments;
 
    // Note: Actual implementation would parse the Segment Sequence
    // to extract segment information
 
    return segments;
}

get_source_reference()

auto kcenon::pacs::ai::ai_result_handler::get_source_reference ( std::string_view result_uid ) -> Result<source_reference>

nodiscard

Get source references for an AI result.

Parameters

result_uid

SOP Instance UID of the AI result

Returns

Result containing source reference or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 635 of file ai_result_handler.cpp.

                                {
    auto it = pimpl_->source_links_.find(std::string(result_uid));
    if (it == pimpl_->source_links_.end()) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("No source reference found for: " +
            std::string(result_uid));
#else
        return std::string("No source reference found for: ") + std::string(result_uid);
#endif
    }
    return it->second;
}

link_to_source() [1/2]

auto kcenon::pacs::ai::ai_result_handler::link_to_source ( std::string_view result_uid, const source_reference & references ) -> VoidResult

nodiscard

Link an AI result with detailed source references.

Parameters

result_uid	SOP Instance UID of the AI result
references	Source references (study, series, instances)

Returns

VoidResult Success or error information

Definition at line 607 of file ai_result_handler.cpp.

                                                      {
    // Verify the AI result exists
    auto it = pimpl_->ai_results_cache_.find(std::string(result_uid));
    if (it == pimpl_->ai_results_cache_.end()) {
        // Try to check storage
        if (!pimpl_->storage_->exists(result_uid)) {
#if KCENON_HAS_COMMON_SYSTEM
            return kcenon::common::error_info("AI result not found: " +
                std::string(result_uid));
#else
            return std::string("AI result not found: ") + std::string(result_uid);
#endif
        }
    }
 
    // Store the source link
    pimpl_->source_links_[std::string(result_uid)] = references;
 
    // Update cached info if present
    if (it != pimpl_->ai_results_cache_.end()) {
        it->second.source_study_uid = references.study_instance_uid;
    }
 
    return ok();
}

link_to_source() [2/2]

auto kcenon::pacs::ai::ai_result_handler::link_to_source ( std::string_view result_uid, std::string_view source_study_uid ) -> VoidResult

nodiscard

Link an AI result to its source study.

Creates a reference association between the AI result and the original study/series/instances it was derived from.

Parameters

result_uid	SOP Instance UID of the AI result
source_study_uid	Study Instance UID of the source

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 599 of file ai_result_handler.cpp.

                                                   {
    source_reference ref;
    ref.study_instance_uid = std::string(source_study_uid);
    return link_to_source(result_uid, ref);
}

References kcenon::pacs::ai::source_reference::study_instance_uid.

operator=() [1/2]

auto kcenon::pacs::ai::ai_result_handler::operator= ( ai_result_handler && ) -> ai_result_handler &

defaultnoexcept

operator=() [2/2]

auto kcenon::pacs::ai::ai_result_handler::operator= ( const ai_result_handler & ) -> ai_result_handler &=delete

delete

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

receive_presentation_state()

auto kcenon::pacs::ai::ai_result_handler::receive_presentation_state ( const core::dicom_dataset & pr ) -> VoidResult

nodiscard

Receive and store an AI-generated Presentation State.

Validates the PR dataset and stores it linked to source images.

Parameters

pr	The Presentation State dataset

Returns

VoidResult Success or error information

Note

Handles annotations and measurements from AI analysis

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 517 of file ai_result_handler.cpp.

                  {
    // Validate SOP Class
    auto sop_class = pr.get_string(core::tags::sop_class_uid);
    auto type = determine_result_type(sop_class);
    if (!type || *type != ai_result_type::presentation_state) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Invalid SOP Class for Presentation State");
#else
        return std::string("Invalid SOP Class for Presentation State");
#endif
    }
 
    // Run common validation
    auto common_validation = pimpl_->validate_common_tags(pr);
    if (common_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            common_validation.error_message.value_or("Validation failed"));
#else
        return common_validation.error_message.value_or("Validation failed");
#endif
    }
 
    // Validate presentation state
    auto pr_validation = validate_presentation_state(pr);
    if (pr_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            pr_validation.error_message.value_or("Presentation state validation failed"));
#else
        return pr_validation.error_message.value_or("Presentation state validation failed");
#endif
    }
 
    // Validate source references if configured
    auto ref_validation = pimpl_->validate_source_references_exist(pr);
    if (ref_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            ref_validation.error_message.value_or("Source reference validation failed"));
#else
        return ref_validation.error_message.value_or("Source reference validation failed");
#endif
    }
 
    // Call pre-store validator if set
    if (pimpl_->pre_store_validator_ &&
        !pimpl_->pre_store_validator_(pr, ai_result_type::presentation_state)) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Pre-store validation rejected the presentation state");
#else
        return std::string("Pre-store validation rejected the presentation state");
#endif
    }
 
    // Store the PR
    return pimpl_->store_ai_result(pr, ai_result_type::presentation_state);
}

References kcenon::pacs::ai::presentation_state, kcenon::pacs::core::tags::sop_class_uid, and kcenon::pacs::ai::valid.

receive_segmentation()

auto kcenon::pacs::ai::ai_result_handler::receive_segmentation ( const core::dicom_dataset & seg ) -> VoidResult

nodiscard

Receive and store an AI-generated Segmentation object.

Validates the SEG dataset for required tags and segment sequence, then stores it and links it to the source images.

Parameters

seg	The Segmentation dataset

Returns

VoidResult Success or error information

Note

Supports both BINARY and FRACTIONAL segment types

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 403 of file ai_result_handler.cpp.

                  {
    // Validate SOP Class
    auto sop_class = seg.get_string(core::tags::sop_class_uid);
    auto type = determine_result_type(sop_class);
    if (!type || *type != ai_result_type::segmentation) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Invalid SOP Class for Segmentation");
#else
        return std::string("Invalid SOP Class for Segmentation");
#endif
    }
 
    // Run common validation
    auto common_validation = pimpl_->validate_common_tags(seg);
    if (common_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            common_validation.error_message.value_or("Validation failed"));
#else
        return common_validation.error_message.value_or("Validation failed");
#endif
    }
 
    // Validate segmentation data
    auto seg_validation = validate_segmentation(seg);
    if (seg_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            seg_validation.error_message.value_or("Segmentation validation failed"));
#else
        return seg_validation.error_message.value_or("Segmentation validation failed");
#endif
    }
 
    // Validate source references if configured
    auto ref_validation = pimpl_->validate_source_references_exist(seg);
    if (ref_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            ref_validation.error_message.value_or("Source reference validation failed"));
#else
        return ref_validation.error_message.value_or("Source reference validation failed");
#endif
    }
 
    // Call pre-store validator if set
    if (pimpl_->pre_store_validator_ &&
        !pimpl_->pre_store_validator_(seg, ai_result_type::segmentation)) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Pre-store validation rejected the segmentation");
#else
        return std::string("Pre-store validation rejected the segmentation");
#endif
    }
 
    // Store the SEG
    return pimpl_->store_ai_result(seg, ai_result_type::segmentation);
}

References kcenon::pacs::ai::segmentation, kcenon::pacs::core::tags::sop_class_uid, and kcenon::pacs::ai::valid.

receive_structured_report()

auto kcenon::pacs::ai::ai_result_handler::receive_structured_report ( const core::dicom_dataset & sr ) -> VoidResult

nodiscard

Receive and store an AI-generated Structured Report.

Validates the SR dataset for required tags and template conformance, then stores it and links it to the source study.

Parameters

sr	The Structured Report dataset

Returns

VoidResult Success or error information

Note

The dataset must contain valid Content Sequence with CAD findings

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 282 of file ai_result_handler.cpp.

                  {
    // Validate SOP Class
    auto sop_class = sr.get_string(core::tags::sop_class_uid);
    auto type = determine_result_type(sop_class);
    if (!type || *type != ai_result_type::structured_report) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Invalid SOP Class for Structured Report");
#else
        return std::string("Invalid SOP Class for Structured Report");
#endif
    }
 
    // Run common validation
    auto common_validation = pimpl_->validate_common_tags(sr);
    if (common_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            common_validation.error_message.value_or("Validation failed"));
#else
        return common_validation.error_message.value_or("Validation failed");
#endif
    }
 
    // Validate SR template if configured
    if (pimpl_->config_.validate_sr_templates) {
        auto template_validation = validate_sr_template(sr);
        if (template_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
            return kcenon::common::error_info(
                template_validation.error_message.value_or("SR template validation failed"));
#else
            return template_validation.error_message.value_or("SR template validation failed");
#endif
        }
    }
 
    // Validate source references if configured
    auto ref_validation = pimpl_->validate_source_references_exist(sr);
    if (ref_validation.status != validation_status::valid) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info(
            ref_validation.error_message.value_or("Source reference validation failed"));
#else
        return ref_validation.error_message.value_or("Source reference validation failed");
#endif
    }
 
    // Call pre-store validator if set
    if (pimpl_->pre_store_validator_ &&
        !pimpl_->pre_store_validator_(sr, ai_result_type::structured_report)) {
#if KCENON_HAS_COMMON_SYSTEM
        return kcenon::common::error_info("Pre-store validation rejected the SR");
#else
        return std::string("Pre-store validation rejected the SR");
#endif
    }
 
    // Store the SR
    return pimpl_->store_ai_result(sr, ai_result_type::structured_report);
}

References kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::ai::structured_report, and kcenon::pacs::ai::valid.

remove()

auto kcenon::pacs::ai::ai_result_handler::remove ( std::string_view sop_instance_uid ) -> VoidResult

nodiscard

Remove an AI result and its source links.

Parameters

sop_instance_uid

SOP Instance UID of the AI result to remove

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 716 of file ai_result_handler.cpp.

                                                                            {
    std::string uid_str(sop_instance_uid);
 
    // Remove from storage
    auto remove_result = pimpl_->storage_->remove(sop_instance_uid);
    if (remove_result.is_err()) {
        return remove_result;
    }
 
    // Remove from cache
    pimpl_->ai_results_cache_.erase(uid_str);
 
    // Remove source links
    pimpl_->source_links_.erase(uid_str);
 
    return ok();
}

remove_ai_results_for_study()

auto kcenon::pacs::ai::ai_result_handler::remove_ai_results_for_study ( std::string_view study_instance_uid ) -> Result<std::size_t>

nodiscard

Remove all AI results linked to a study.

Parameters

study_instance_uid

Study Instance UID

Returns

Result containing count of removed results or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 734 of file ai_result_handler.cpp.

                         {
    std::size_t removed_count = 0;
 
    // Find all AI results for this study
    std::vector<std::string> to_remove;
    for (const auto& [uid, info] : pimpl_->ai_results_cache_) {
        if (info.source_study_uid == study_instance_uid) {
            to_remove.push_back(uid);
        }
    }
 
    // Remove each one
    for (const auto& uid : to_remove) {
        auto result = remove(uid);
        if (result.is_ok()) {
            ++removed_count;
        }
    }
 
    return removed_count;
}

References uid.

set_pre_store_validator()

void kcenon::pacs::ai::ai_result_handler::set_pre_store_validator

(

pre_store_validator

validator

)

Set custom pre-storage validator.

Parameters

validator

Function to validate before storage

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 274 of file ai_result_handler.cpp.

                                                                             {
    pimpl_->pre_store_validator_ = std::move(validator);
}

References pimpl_, and kcenon::pacs::ai::ai_result_handler::impl::pre_store_validator_.

set_received_callback()

void kcenon::pacs::ai::ai_result_handler::set_received_callback

(

ai_result_received_callback

callback

)

Set callback for AI result reception notifications.

Parameters

callback

Function to call when AI result is received

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 270 of file ai_result_handler.cpp.

                                                                                  {
    pimpl_->received_callback_ = std::move(callback);
}

References pimpl_, and kcenon::pacs::ai::ai_result_handler::impl::received_callback_.

validate_presentation_state()

auto kcenon::pacs::ai::ai_result_handler::validate_presentation_state ( const core::dicom_dataset & pr ) -> validation_result

nodiscard

Validate Presentation State.

Parameters

pr	The Presentation State dataset to validate

Returns

Validation result with status and details

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 577 of file ai_result_handler.cpp.

                         {
    validation_result result;
    result.status = validation_status::valid;
 
    // Note: Referenced Series Sequence (0008,1115) validation would be done here
    // for full presentation state conformance checking
 
    // Basic validation - ensure presentation state has valid SOP Class UID
    auto sop_class = pr.get_string(core::tags::sop_class_uid);
    if (sop_class.empty()) {
        result.status = validation_status::missing_required_tags;
        result.missing_tags.push_back("SOP Class UID");
    }
 
    return result;
}

References kcenon::pacs::ai::missing_required_tags, kcenon::pacs::ai::validation_result::missing_tags, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::ai::validation_result::status, and kcenon::pacs::ai::valid.

validate_segmentation()

auto kcenon::pacs::ai::ai_result_handler::validate_segmentation ( const core::dicom_dataset & seg ) -> validation_result

nodiscard

Validate segmentation data integrity.

Parameters

seg	The Segmentation dataset to validate

Returns

Validation result with status and details

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 463 of file ai_result_handler.cpp.

                         {
    validation_result result;
    result.status = validation_status::valid;
 
    // Note: Segment Sequence (0062,0002) validation would be done here
    // for full segmentation conformance checking
 
    // Check Segmentation Type
    // Tag (0062,0001) Segmentation Type
    const core::dicom_tag seg_type_tag(0x0062, 0x0001);
    auto seg_type = seg.get_string(seg_type_tag);
 
    if (seg_type != "BINARY" && seg_type != "FRACTIONAL" && !seg_type.empty()) {
        result.status = validation_status::invalid_segment_data;
        result.error_message = "Invalid segmentation type: " + seg_type;
        return result;
    }
 
    // Check segment count if max_segments is configured
    if (pimpl_->config_.max_segments > 0) {
        // Tag (0062,0004) Number of Segments
        // This would need proper implementation based on actual tag
    }
 
    return result;
}

References kcenon::pacs::ai::validation_result::error_message, kcenon::pacs::ai::invalid_segment_data, kcenon::pacs::ai::validation_result::status, and kcenon::pacs::ai::valid.

validate_sr_template()

auto kcenon::pacs::ai::ai_result_handler::validate_sr_template ( const core::dicom_dataset & sr ) -> validation_result

nodiscard

Validate SR template conformance.

Parameters

sr	The Structured Report dataset to validate

Returns

Validation result with status and details

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 344 of file ai_result_handler.cpp.

                         {
    validation_result result;
    result.status = validation_status::valid;
 
    // Note: Content Sequence (0040,A730) validation would be done here
    // for full SR template conformance checking
 
    // Check for Template Identifier if configured
    if (!pimpl_->config_.accepted_sr_templates.empty()) {
        // Tag (0040,DB00) Template Identifier
        const core::dicom_tag template_id_tag(0x0040, 0xDB00);
        auto template_id = sr.get_string(template_id_tag);
 
        bool template_found = false;
        for (const auto& accepted : pimpl_->config_.accepted_sr_templates) {
            if (template_id == accepted) {
                template_found = true;
                break;
            }
        }
 
        if (!template_found && !template_id.empty()) {
            result.status = validation_status::invalid_template;
            result.error_message = "SR template not in accepted list: " + template_id;
        }
    }
 
    return result;
}

References kcenon::pacs::ai::validation_result::error_message, kcenon::pacs::ai::invalid_template, kcenon::pacs::ai::validation_result::status, and kcenon::pacs::ai::valid.

Member Data Documentation

pimpl_

std::unique_ptr<impl> kcenon::pacs::ai::ai_result_handler::pimpl_

private

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/ai/ai_result_handler.h.

Definition at line 525 of file ai_result_handler.h.

Referenced by get_config(), set_pre_store_validator(), and set_received_callback().

---

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

• include/kcenon/pacs/ai/ai_result_handler.h
• src/ai/ai_result_handler.cpp