Validator for Structured Report IODs. More...

#include <sr_iod_validator.h>

Collaboration diagram for kcenon::pacs::services::validation::sr_iod_validator:

Public Member Functions
	sr_iod_validator ()=default
	Construct validator with default options.

	sr_iod_validator (const sr_validation_options &options)
	Construct validator with custom options.

validation_result	validate (const core::dicom_dataset &dataset) const
	Validate a DICOM dataset against SR IOD.

validation_result	validate_basic_text_sr (const core::dicom_dataset &dataset) const
	Validate a Basic Text SR dataset.

validation_result	validate_enhanced_sr (const core::dicom_dataset &dataset) const
	Validate an Enhanced SR dataset.

validation_result	validate_comprehensive_sr (const core::dicom_dataset &dataset) const
	Validate a Comprehensive SR dataset.

validation_result	validate_key_object_selection (const core::dicom_dataset &dataset) const
	Validate a Key Object Selection document.

validation_result	validate_content_tree (const core::dicom_dataset &dataset) const
	Validate content tree structure.

validation_result	validate_references (const core::dicom_dataset &dataset) const
	Validate referenced instances.

bool	quick_check (const core::dicom_dataset &dataset) const
	Quick check if dataset has minimum required attributes.

const sr_validation_options &	options () const noexcept
	Get the validation options.

void	set_options (const sr_validation_options &options)
	Set validation options.

Private Member Functions
void	validate_patient_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_general_study_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_sr_document_series_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_general_equipment_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_sr_document_general_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_sr_document_content_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_sop_common_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_evidence_sequences (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_content_sequence (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_content_item (const core::dicom_dataset &item, size_t depth, std::string_view parent_value_type, std::vector< validation_finding > &findings) const

void	validate_coded_entry (const core::dicom_dataset &coded_entry, std::string_view context, std::vector< validation_finding > &findings) const

void	validate_text_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	validate_code_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	validate_num_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	validate_image_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	validate_scoord_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	validate_scoord3d_content_item (const core::dicom_dataset &item, std::vector< validation_finding > &findings) const

void	check_type1_attribute (const core::dicom_dataset &dataset, core::dicom_tag tag, std::string_view name, std::vector< validation_finding > &findings) const

void	check_type2_attribute (const core::dicom_dataset &dataset, core::dicom_tag tag, std::string_view name, std::vector< validation_finding > &findings) const

void	check_modality (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	check_completion_flag (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	check_verification_flag (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

Private Attributes
sr_validation_options	options_

Detailed Description

Validator for Structured Report IODs.

Validates DICOM datasets against various SR Document IOD specifications. Supports Basic Text SR, Enhanced SR, Comprehensive SR, and specialized SR documents including CAD SR and Key Object Selection.

Validated Modules

Common Modules (All SR Types)

Patient Module (M)
General Study Module (M)
SR Document Series Module (M)
General Equipment Module (M)
SR Document General Module (M)
SR Document Content Module (M)
SOP Common Module (M)

Enhanced SR Additional Modules

Current Requested Procedure Evidence Sequence (1C)
Pertinent Other Evidence Sequence (1C)

Comprehensive SR Additional Modules

SCOORD/SCOORD3D support

Example:: sr_iod_validator validator;

auto result = validator.validate(dataset);

if (!result.is_valid) {

for (const auto& finding : result.findings) {

std::cerr << finding.code << ": " << finding.message << "\n";

}

}

kcenon::pacs::services::validation::sr_iod_validator
Validator for Structured Report IODs.
Definition sr_iod_validator.h:117

kcenon::pacs::services::validation::sr_iod_validator::validate
validation_result validate(const core::dicom_dataset &dataset) const
Validate a DICOM dataset against SR IOD.
Definition sr_iod_validator.cpp:92

Definition at line 117 of file sr_iod_validator.h.

Constructor & Destructor Documentation

◆ sr_iod_validator() [1/2]

kcenon::pacs::services::validation::sr_iod_validator::sr_iod_validator ( )

default

Construct validator with default options.

◆ sr_iod_validator() [2/2]

kcenon::pacs::services::validation::sr_iod_validator::sr_iod_validator ( const sr_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options Validation options

Definition at line 89 of file sr_iod_validator.cpp.

90 : options_(options) {}

kcenon::pacs::services::validation::sr_iod_validator::options

const sr_validation_options & options() const noexcept

Get the validation options.

Definition sr_iod_validator.cpp:338

kcenon::pacs::services::validation::sr_iod_validator::options_

sr_validation_options options_

Definition sr_iod_validator.h:318

Member Function Documentation

◆ check_completion_flag()

void kcenon::pacs::services::validation::sr_iod_validator::check_completion_flag	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 918 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(sr_tags::completion_flag)) {
        return;
    }
 
    auto flag = dataset.get_string(sr_tags::completion_flag);
    if (flag != "PARTIAL" && flag != "COMPLETE") {
        findings.push_back({
            validation_severity::error,
            sr_tags::completion_flag,
            "Invalid CompletionFlag value: " + flag + " (must be PARTIAL or COMPLETE)",
            "SR-FLAG-ERR-001"
        });
    }
}

References kcenon::pacs::services::validation::sr_tags::completion_flag, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, and kcenon::pacs::core::dicom_dataset::get_string().

Referenced by validate_sr_document_general_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_modality()

void kcenon::pacs::services::validation::sr_iod_validator::check_modality	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 899 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::modality)) {
        return;
    }
 
    auto modality = dataset.get_string(tags::modality);
    if (modality != "SR") {
        findings.push_back({
            validation_severity::error,
            tags::modality,
            "Modality must be 'SR' for Structured Report objects, found: " + modality,
            "SR-ERR-002"
        });
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), and kcenon::pacs::core::tags::modality.

Referenced by validate_sr_document_series_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_type1_attribute()

void kcenon::pacs::services::validation::sr_iod_validator::check_type1_attribute	(	const core::dicom_dataset &	dataset,
		core::dicom_tag	tag,
		std::string_view	name,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 837 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tag)) {
        findings.push_back({
            validation_severity::error,
            tag,
            std::string("Type 1 attribute missing: ") + std::string(name) +
            " (" + tag.to_string() + ")",
            "SR-TYPE1-MISSING"
        });
    } else {
        const auto* element = dataset.get(tag);
        if (element != nullptr) {
            // For sequences, check if the sequence has items
            if (element->is_sequence()) {
                if (element->sequence_items().empty()) {
                    findings.push_back({
                        validation_severity::error,
                        tag,
                        std::string("Type 1 sequence has no items: ") +
                        std::string(name) + " (" + tag.to_string() + ")",
                        "SR-TYPE1-EMPTY"
                    });
                }
            } else {
                // For non-sequence elements, check if the value is empty
                auto value = dataset.get_string(tag);
                if (value.empty()) {
                    findings.push_back({
                        validation_severity::error,
                        tag,
                        std::string("Type 1 attribute has empty value: ") +
                        std::string(name) + " (" + tag.to_string() + ")",
                        "SR-TYPE1-EMPTY"
                    });
                }
            }
        }
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get(), kcenon::pacs::core::dicom_dataset::get_string(), name, and kcenon::pacs::core::dicom_tag::to_string().

Referenced by validate_general_study_module(), validate_sop_common_module(), validate_sr_document_content_module(), validate_sr_document_general_module(), and validate_sr_document_series_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_type2_attribute()

void kcenon::pacs::services::validation::sr_iod_validator::check_type2_attribute	(	const core::dicom_dataset &	dataset,
		core::dicom_tag	tag,
		std::string_view	name,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 882 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tag)) {
        findings.push_back({
            validation_severity::warning,
            tag,
            std::string("Type 2 attribute missing: ") + std::string(name) +
            " (" + tag.to_string() + ")",
            "SR-TYPE2-MISSING"
        });
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), name, kcenon::pacs::core::dicom_tag::to_string(), and kcenon::pacs::services::validation::warning.

Referenced by validate_general_equipment_module(), validate_general_study_module(), validate_patient_module(), validate_sr_document_general_module(), and validate_sr_document_series_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_verification_flag()

void kcenon::pacs::services::validation::sr_iod_validator::check_verification_flag	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 937 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(sr_tags::verification_flag)) {
        return;
    }
 
    auto flag = dataset.get_string(sr_tags::verification_flag);
    if (flag != "UNVERIFIED" && flag != "VERIFIED") {
        findings.push_back({
            validation_severity::error,
            sr_tags::verification_flag,
            "Invalid VerificationFlag value: " + flag + " (must be UNVERIFIED or VERIFIED)",
            "SR-FLAG-ERR-002"
        });
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), and kcenon::pacs::services::validation::sr_tags::verification_flag.

Referenced by validate_sr_document_general_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ options()

const sr_validation_options & kcenon::pacs::services::validation::sr_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Definition at line 338 of file sr_iod_validator.cpp.

                                                                      {
    return options_;
}

References options_.

Referenced by set_options().

Here is the caller graph for this function:

◆ quick_check()

bool kcenon::pacs::services::validation::sr_iod_validator::quick_check ( const core::dicom_dataset & dataset ) const

nodiscard

Quick check if dataset has minimum required attributes.

Faster than full validation - only checks Type 1 attributes.

Parameters

dataset The dataset to check

Returns: true if all Type 1 attributes are present

Definition at line 305 of file sr_iod_validator.cpp.

                                                                     {
    // Check essential Type 1 attributes
 
    // General Study Module
    if (!dataset.contains(tags::study_instance_uid)) return false;
 
    // General Series Module
    if (!dataset.contains(tags::modality)) return false;
    if (!dataset.contains(tags::series_instance_uid)) return false;
 
    // Check modality is SR
    auto modality = dataset.get_string(tags::modality);
    if (modality != "SR") return false;
 
    // SR Document General Module
    if (!dataset.contains(sr_tags::completion_flag)) return false;
    if (!dataset.contains(sr_tags::verification_flag)) return false;
 
    // SR Document Content Module - root content item
    if (!dataset.contains(sr_tags::value_type)) return false;
    if (!dataset.contains(sr_tags::concept_name_code_sequence)) return false;
 
    // SOP Common Module
    if (!dataset.contains(tags::sop_class_uid)) return false;
    if (!dataset.contains(tags::sop_instance_uid)) return false;
 
    // Verify SOP Class is SR
    auto sop_class = dataset.get_string(tags::sop_class_uid);
    if (!sop_classes::is_sr_storage_sop_class(sop_class)) return false;
 
    return true;
}

References kcenon::pacs::services::validation::sr_tags::completion_flag, kcenon::pacs::services::validation::sr_tags::concept_name_code_sequence, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::is_sr_storage_sop_class(), kcenon::pacs::core::tags::modality, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, kcenon::pacs::core::tags::study_instance_uid, kcenon::pacs::services::validation::sr_tags::value_type, and kcenon::pacs::services::validation::sr_tags::verification_flag.

Referenced by kcenon::pacs::services::validation::is_valid_sr_dataset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_options()

void kcenon::pacs::services::validation::sr_iod_validator::set_options ( const sr_validation_options & options )

Set validation options.

Definition at line 342 of file sr_iod_validator.cpp.

                                                                       {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

◆ validate()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a DICOM dataset against SR IOD.

Automatically detects the SR type and applies appropriate validation.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 92 of file sr_iod_validator.cpp.

                                                                               {
    // Detect SR type and delegate to appropriate validation
    if (!dataset.contains(tags::sop_class_uid)) {
        validation_result result;
        result.is_valid = false;
        result.findings.push_back({
            validation_severity::error,
            tags::sop_class_uid,
            "SOPClassUID is required to determine SR type",
            "SR-ERR-000"
        });
        return result;
    }
 
    auto sop_class = dataset.get_string(tags::sop_class_uid);
    auto doc_type = sop_classes::get_sr_document_type(sop_class);
 
    switch (doc_type) {
        case sop_classes::sr_document_type::basic_text:
            return validate_basic_text_sr(dataset);
        case sop_classes::sr_document_type::enhanced:
            return validate_enhanced_sr(dataset);
        case sop_classes::sr_document_type::comprehensive:
        case sop_classes::sr_document_type::comprehensive_3d:
            return validate_comprehensive_sr(dataset);
        case sop_classes::sr_document_type::key_object_selection:
            return validate_key_object_selection(dataset);
        default:
            // For other types, use comprehensive validation
            return validate_comprehensive_sr(dataset);
    }
}

Referenced by kcenon::pacs::services::validation::validate_sr_iod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_basic_text_sr()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_basic_text_sr ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a Basic Text SR dataset.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 126 of file sr_iod_validator.cpp.

                                                                           {
    validation_result result;
    result.is_valid = true;
 
    // Common modules
    validate_patient_module(dataset, result.findings);
    validate_general_study_module(dataset, result.findings);
    validate_sr_document_series_module(dataset, result.findings);
    validate_general_equipment_module(dataset, result.findings);
    validate_sr_document_general_module(dataset, result.findings);
    validate_sr_document_content_module(dataset, result.findings);
    validate_sop_common_module(dataset, result.findings);
 
    // Basic Text SR does not support SCOORD, IMAGE, WAVEFORM, etc.
    // Content validation will handle value type restrictions
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
        if (options_.strict_mode && finding.severity == validation_severity::warning) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, options_, kcenon::pacs::services::validation::sr_validation_options::strict_mode, validate_general_equipment_module(), validate_general_study_module(), validate_patient_module(), validate_sop_common_module(), validate_sr_document_content_module(), validate_sr_document_general_module(), validate_sr_document_series_module(), and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_code_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_code_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 688 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::concept_name_code_sequence)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::concept_name_code_sequence,
            "ConceptNameCodeSequence is required for CODE content item",
            "SR-CODE-ITEM-ERR-001"
        });
    }
}

References kcenon::pacs::services::validation::sr_tags::concept_name_code_sequence, and kcenon::pacs::services::validation::error.

Referenced by validate_content_item().

Here is the caller graph for this function:

◆ validate_coded_entry()

void kcenon::pacs::services::validation::sr_iod_validator::validate_coded_entry	(	const core::dicom_dataset &	coded_entry,
		std::string_view	context,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 638 of file sr_iod_validator.cpp.

                                                   {
 
    // Code Value
    if (!coded_entry.contains(sr_tags::code_value)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::code_value,
            std::string(context) + ": CodeValue is required",
            "SR-CODE-ERR-001"
        });
    }
 
    // Coding Scheme Designator
    if (!coded_entry.contains(sr_tags::coding_scheme_designator)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::coding_scheme_designator,
            std::string(context) + ": CodingSchemeDesignator is required",
            "SR-CODE-ERR-002"
        });
    }
 
    // Code Meaning
    if (!coded_entry.contains(sr_tags::code_meaning)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::code_meaning,
            std::string(context) + ": CodeMeaning is required",
            "SR-CODE-ERR-003"
        });
    }
}

References kcenon::pacs::services::validation::sr_tags::code_meaning, kcenon::pacs::services::validation::sr_tags::code_value, kcenon::pacs::services::validation::sr_tags::coding_scheme_designator, kcenon::pacs::core::dicom_dataset::contains(), and kcenon::pacs::services::validation::error.

Referenced by validate_sr_document_content_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_comprehensive_sr()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_comprehensive_sr ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a Comprehensive SR dataset.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 190 of file sr_iod_validator.cpp.

                                                                              {
    validation_result result;
    result.is_valid = true;
 
    // Common modules
    validate_patient_module(dataset, result.findings);
    validate_general_study_module(dataset, result.findings);
    validate_sr_document_series_module(dataset, result.findings);
    validate_general_equipment_module(dataset, result.findings);
    validate_sr_document_general_module(dataset, result.findings);
    validate_sr_document_content_module(dataset, result.findings);
    validate_sop_common_module(dataset, result.findings);
 
    // Comprehensive SR specific - evidence sequences
    if (options_.validate_references) {
        validate_evidence_sequences(dataset, result.findings);
    }
 
    // Content tree validation (includes SCOORD support)
    if (options_.validate_content_sequence) {
        validate_content_sequence(dataset, result.findings);
    }
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
        if (options_.strict_mode && finding.severity == validation_severity::warning) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, options_, kcenon::pacs::services::validation::sr_validation_options::strict_mode, validate_content_sequence(), kcenon::pacs::services::validation::sr_validation_options::validate_content_sequence, validate_evidence_sequences(), validate_general_equipment_module(), validate_general_study_module(), validate_patient_module(), kcenon::pacs::services::validation::sr_validation_options::validate_references, validate_sop_common_module(), validate_sr_document_content_module(), validate_sr_document_general_module(), validate_sr_document_series_module(), and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_content_item	(	const core::dicom_dataset &	item,
		size_t	depth,
		std::string_view	parent_value_type,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 552 of file sr_iod_validator.cpp.

                                                   {
 
    // Prevent infinite recursion
    if (depth > 100) {
        findings.push_back({
            validation_severity::warning,
            sr_tags::content_sequence,
            "Content tree depth exceeds 100 - possible circular reference",
            "SR-CONTENT-WARN-001"
        });
        return;
    }
 
    // Check required attributes
    if (!item.contains(sr_tags::relationship_type)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::relationship_type,
            "RelationshipType missing in content item at depth " + std::to_string(depth),
            "SR-ITEM-ERR-001"
        });
    }
 
    if (!item.contains(sr_tags::value_type)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::value_type,
            "ValueType missing in content item at depth " + std::to_string(depth),
            "SR-ITEM-ERR-002"
        });
        return;  // Can't validate further without value type
    }
 
    auto value_type = item.get_string(sr_tags::value_type);
    auto sr_vt = sop_classes::parse_sr_value_type(value_type);
 
    if (sr_vt == sop_classes::sr_value_type::unknown) {
        findings.push_back({
            validation_severity::error,
            sr_tags::value_type,
            "Invalid ValueType: " + value_type,
            "SR-ITEM-ERR-003"
        });
        return;
    }
 
    // Value type specific validation
    switch (sr_vt) {
        case sop_classes::sr_value_type::text:
            validate_text_content_item(item, findings);
            break;
        case sop_classes::sr_value_type::code:
            validate_code_content_item(item, findings);
            break;
        case sop_classes::sr_value_type::num:
            validate_num_content_item(item, findings);
            break;
        case sop_classes::sr_value_type::image:
            validate_image_content_item(item, findings);
            break;
        case sop_classes::sr_value_type::scoord:
            validate_scoord_content_item(item, findings);
            break;
        case sop_classes::sr_value_type::scoord3d:
            validate_scoord3d_content_item(item, findings);
            break;
        default:
            break;
    }
 
    // Validate nested content items
    if (item.contains(sr_tags::content_sequence)) {
        const auto* nested_elem = item.get(sr_tags::content_sequence);
        if (nested_elem && nested_elem->is_sequence()) {
            const auto& nested_seq = nested_elem->sequence_items();
            for (size_t i = 0; i < nested_seq.size(); ++i) {
                validate_content_item(nested_seq[i], depth + 1, value_type, findings);
            }
        }
    }
}

Referenced by validate_content_item(), and validate_content_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_content_sequence()

void kcenon::pacs::services::validation::sr_iod_validator::validate_content_sequence	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 517 of file sr_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(sr_tags::content_sequence)) {
        findings.push_back({
            validation_severity::info,
            sr_tags::content_sequence,
            "ContentSequence not present - SR document has no content items",
            "SR-CONTENT-INFO-001"
        });
        return;
    }
 
    const auto* content_elem = dataset.get(sr_tags::content_sequence);
    if (!content_elem || !content_elem->is_sequence() || content_elem->sequence_items().empty()) {
        findings.push_back({
            validation_severity::info,
            sr_tags::content_sequence,
            "ContentSequence is empty",
            "SR-CONTENT-INFO-002"
        });
        return;
    }
 
    // Get root value type for context
    auto root_value_type = dataset.get_string(sr_tags::value_type);
 
    // Validate each content item
    const auto& content_seq = content_elem->sequence_items();
    for (size_t i = 0; i < content_seq.size(); ++i) {
        validate_content_item(content_seq[i], 1, root_value_type, findings);
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::sr_tags::content_sequence, kcenon::pacs::core::dicom_dataset::get(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::info, validate_content_item(), and kcenon::pacs::services::validation::sr_tags::value_type.

Referenced by validate_comprehensive_sr(), validate_content_tree(), and validate_sr_document_content_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_content_tree()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_content_tree ( const core::dicom_dataset & dataset ) const

nodiscard

Validate content tree structure.

Validates the Content Sequence hierarchy and relationships.

Parameters

dataset The dataset to validate

Returns: Validation result for content tree

Definition at line 272 of file sr_iod_validator.cpp.

                                                                          {
    validation_result result;
    result.is_valid = true;
 
    validate_content_sequence(dataset, result.findings);
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, and validate_content_sequence().

Here is the call graph for this function:

◆ validate_enhanced_sr()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_enhanced_sr ( const core::dicom_dataset & dataset ) const

nodiscard

Validate an Enhanced SR dataset.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 157 of file sr_iod_validator.cpp.

                                                                         {
    validation_result result;
    result.is_valid = true;
 
    // Common modules
    validate_patient_module(dataset, result.findings);
    validate_general_study_module(dataset, result.findings);
    validate_sr_document_series_module(dataset, result.findings);
    validate_general_equipment_module(dataset, result.findings);
    validate_sr_document_general_module(dataset, result.findings);
    validate_sr_document_content_module(dataset, result.findings);
    validate_sop_common_module(dataset, result.findings);
 
    // Enhanced SR specific - evidence sequences
    if (options_.validate_references) {
        validate_evidence_sequences(dataset, result.findings);
    }
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
        if (options_.strict_mode && finding.severity == validation_severity::warning) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, options_, kcenon::pacs::services::validation::sr_validation_options::strict_mode, validate_evidence_sequences(), validate_general_equipment_module(), validate_general_study_module(), validate_patient_module(), kcenon::pacs::services::validation::sr_validation_options::validate_references, validate_sop_common_module(), validate_sr_document_content_module(), validate_sr_document_general_module(), validate_sr_document_series_module(), and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_evidence_sequences()

void kcenon::pacs::services::validation::sr_iod_validator::validate_evidence_sequences	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 499 of file sr_iod_validator.cpp.

                                                   {
 
    // For Enhanced/Comprehensive SR, at least one evidence sequence should be present
    bool has_evidence = dataset.contains(sr_tags::current_requested_procedure_evidence_sequence) ||
                       dataset.contains(sr_tags::pertinent_other_evidence_sequence);
 
    if (!has_evidence) {
        findings.push_back({
            validation_severity::info,
            sr_tags::current_requested_procedure_evidence_sequence,
            "No evidence sequences present - SR may not properly link to source images",
            "SR-EVIDENCE-INFO-001"
        });
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::sr_tags::current_requested_procedure_evidence_sequence, kcenon::pacs::services::validation::info, and kcenon::pacs::services::validation::sr_tags::pertinent_other_evidence_sequence.

Referenced by validate_comprehensive_sr(), validate_enhanced_sr(), and validate_references().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_general_equipment_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_general_equipment_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 394 of file sr_iod_validator.cpp.

                                                   {
 
    constexpr dicom_tag manufacturer{0x0008, 0x0070};
    if (options_.check_type2) {
        check_type2_attribute(dataset, manufacturer, "Manufacturer", findings);
    }
}

References kcenon::pacs::services::validation::sr_validation_options::check_type2, check_type2_attribute(), and options_.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_general_study_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_general_study_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 362 of file sr_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::study_instance_uid, "StudyInstanceUID", findings);
    }
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, tags::study_date, "StudyDate", findings);
        check_type2_attribute(dataset, tags::study_time, "StudyTime", findings);
        check_type2_attribute(dataset, tags::referring_physician_name, "ReferringPhysicianName", findings);
        check_type2_attribute(dataset, tags::study_id, "StudyID", findings);
        check_type2_attribute(dataset, tags::accession_number, "AccessionNumber", findings);
    }
}

References kcenon::pacs::core::tags::accession_number, kcenon::pacs::services::validation::sr_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::sr_validation_options::check_type2, check_type2_attribute(), options_, kcenon::pacs::core::tags::referring_physician_name, kcenon::pacs::core::tags::study_date, kcenon::pacs::core::tags::study_id, kcenon::pacs::core::tags::study_instance_uid, and kcenon::pacs::core::tags::study_time.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_image_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_image_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 740 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::referenced_sop_sequence)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::referenced_sop_sequence,
            "ReferencedSOPSequence is required for IMAGE content item",
            "SR-IMAGE-ERR-001"
        });
        return;
    }
 
    const auto* ref_elem = item.get(sr_tags::referenced_sop_sequence);
    if (ref_elem && ref_elem->is_sequence() && !ref_elem->sequence_items().empty()) {
        const auto& ref_item = ref_elem->sequence_items()[0];
 
        if (!ref_item.contains(sr_tags::referenced_sop_class_uid)) {
            findings.push_back({
                validation_severity::error,
                sr_tags::referenced_sop_class_uid,
                "ReferencedSOPClassUID is required in IMAGE reference",
                "SR-IMAGE-ERR-002"
            });
        }
 
        if (!ref_item.contains(sr_tags::referenced_sop_instance_uid)) {
            findings.push_back({
                validation_severity::error,
                sr_tags::referenced_sop_instance_uid,
                "ReferencedSOPInstanceUID is required in IMAGE reference",
                "SR-IMAGE-ERR-003"
            });
        }
    }
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::sr_tags::referenced_sop_class_uid, kcenon::pacs::services::validation::sr_tags::referenced_sop_instance_uid, and kcenon::pacs::services::validation::sr_tags::referenced_sop_sequence.

Referenced by validate_content_item().

Here is the caller graph for this function:

◆ validate_key_object_selection()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_key_object_selection ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a Key Object Selection document.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 228 of file sr_iod_validator.cpp.

                                                                                  {
    validation_result result;
    result.is_valid = true;
 
    if (!options_.validate_key_object_selection) {
        return result;
    }
 
    // Common modules
    validate_patient_module(dataset, result.findings);
    validate_general_study_module(dataset, result.findings);
    validate_sr_document_series_module(dataset, result.findings);
    validate_general_equipment_module(dataset, result.findings);
    validate_sr_document_general_module(dataset, result.findings);
    validate_sr_document_content_module(dataset, result.findings);
    validate_sop_common_module(dataset, result.findings);
 
    // KOS must have Current Requested Procedure Evidence Sequence
    if (options_.check_type1) {
        if (!dataset.contains(sr_tags::current_requested_procedure_evidence_sequence)) {
            result.findings.push_back({
                validation_severity::error,
                sr_tags::current_requested_procedure_evidence_sequence,
                "CurrentRequestedProcedureEvidenceSequence is required for Key Object Selection",
                "SR-KOS-ERR-001"
            });
        }
    }
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
        if (options_.strict_mode && finding.severity == validation_severity::warning) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_num_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_num_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 702 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::measured_value_sequence)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::measured_value_sequence,
            "MeasuredValueSequence is required for NUM content item",
            "SR-NUM-ERR-001"
        });
        return;
    }
 
    const auto* measured_elem = item.get(sr_tags::measured_value_sequence);
    if (measured_elem && measured_elem->is_sequence() && !measured_elem->sequence_items().empty()) {
        const auto& mv_item = measured_elem->sequence_items()[0];
 
        if (!mv_item.contains(sr_tags::numeric_value)) {
            findings.push_back({
                validation_severity::error,
                sr_tags::numeric_value,
                "NumericValue is required in MeasuredValueSequence",
                "SR-NUM-ERR-002"
            });
        }
 
        if (!mv_item.contains(sr_tags::measurement_units_code_sequence)) {
            findings.push_back({
                validation_severity::error,
                sr_tags::measurement_units_code_sequence,
                "MeasurementUnitsCodeSequence is required in MeasuredValueSequence",
                "SR-NUM-ERR-003"
            });
        }
    }
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::sr_tags::measured_value_sequence, kcenon::pacs::services::validation::sr_tags::measurement_units_code_sequence, and kcenon::pacs::services::validation::sr_tags::numeric_value.

Referenced by validate_content_item().

Here is the caller graph for this function:

◆ validate_patient_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_patient_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 350 of file sr_iod_validator.cpp.

                                                   {
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, tags::patient_name, "PatientName", findings);
        check_type2_attribute(dataset, tags::patient_id, "PatientID", findings);
        check_type2_attribute(dataset, tags::patient_birth_date, "PatientBirthDate", findings);
        check_type2_attribute(dataset, tags::patient_sex, "PatientSex", findings);
    }
}

References kcenon::pacs::services::validation::sr_validation_options::check_type2, check_type2_attribute(), options_, kcenon::pacs::core::tags::patient_birth_date, kcenon::pacs::core::tags::patient_id, kcenon::pacs::core::tags::patient_name, and kcenon::pacs::core::tags::patient_sex.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_references()

validation_result kcenon::pacs::services::validation::sr_iod_validator::validate_references ( const core::dicom_dataset & dataset ) const

nodiscard

Validate referenced instances.

Checks that all referenced SOP instances are properly specified.

Parameters

dataset The dataset to validate

Returns: Validation result for references

Definition at line 289 of file sr_iod_validator.cpp.

                                                                        {
    validation_result result;
    result.is_valid = true;
 
    validate_evidence_sequences(dataset, result.findings);
 
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, and validate_evidence_sequences().

Here is the call graph for this function:

◆ validate_scoord3d_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_scoord3d_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 801 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::graphic_type)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::graphic_type,
            "GraphicType is required for SCOORD3D content item",
            "SR-SCOORD3D-ERR-001"
        });
    }
 
    if (!item.contains(sr_tags::graphic_data)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::graphic_data,
            "GraphicData is required for SCOORD3D content item",
            "SR-SCOORD3D-ERR-002"
        });
    }
 
    if (!item.contains(sr_tags::referenced_frame_of_reference_uid)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::referenced_frame_of_reference_uid,
            "ReferencedFrameOfReferenceUID is required for SCOORD3D content item",
            "SR-SCOORD3D-ERR-003"
        });
    }
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::sr_tags::graphic_data, kcenon::pacs::services::validation::sr_tags::graphic_type, and kcenon::pacs::services::validation::sr_tags::referenced_frame_of_reference_uid.

Referenced by validate_content_item().

Here is the caller graph for this function:

◆ validate_scoord_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_scoord_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 778 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::graphic_type)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::graphic_type,
            "GraphicType is required for SCOORD content item",
            "SR-SCOORD-ERR-001"
        });
    }
 
    if (!item.contains(sr_tags::graphic_data)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::graphic_data,
            "GraphicData is required for SCOORD content item",
            "SR-SCOORD-ERR-002"
        });
    }
}

References kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::sr_tags::graphic_data, and kcenon::pacs::services::validation::sr_tags::graphic_type.

Referenced by validate_content_item().

Here is the caller graph for this function:

◆ validate_sop_common_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_sop_common_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 476 of file sr_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::sop_class_uid, "SOPClassUID", findings);
        check_type1_attribute(dataset, tags::sop_instance_uid, "SOPInstanceUID", findings);
    }
 
    // Validate SOP Class UID is an SR storage class
    if (dataset.contains(tags::sop_class_uid)) {
        auto sop_class = dataset.get_string(tags::sop_class_uid);
        if (!sop_classes::is_sr_storage_sop_class(sop_class)) {
            findings.push_back({
                validation_severity::error,
                tags::sop_class_uid,
                "SOPClassUID is not a recognized SR Storage SOP Class: " + sop_class,
                "SR-ERR-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::sr_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::is_sr_storage_sop_class(), options_, kcenon::pacs::core::tags::sop_class_uid, and kcenon::pacs::core::tags::sop_instance_uid.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_sr_document_content_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_sr_document_content_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 439 of file sr_iod_validator.cpp.

                                                   {
 
    // Root content item attributes
    if (options_.check_type1) {
        check_type1_attribute(dataset, sr_tags::value_type, "ValueType", findings);
        check_type1_attribute(dataset, sr_tags::concept_name_code_sequence, "ConceptNameCodeSequence", findings);
    }
 
    // Validate root value type
    if (options_.validate_value_types && dataset.contains(sr_tags::value_type)) {
        auto value_type = dataset.get_string(sr_tags::value_type);
        if (value_type != "CONTAINER") {
            findings.push_back({
                validation_severity::error,
                sr_tags::value_type,
                "Root content item ValueType must be CONTAINER, found: " + value_type,
                "SR-CONTENT-ERR-001"
            });
        }
    }
 
    // Validate Concept Name Code Sequence
    if (options_.validate_coded_entries && dataset.contains(sr_tags::concept_name_code_sequence)) {
        const auto* concept_elem = dataset.get(sr_tags::concept_name_code_sequence);
        if (concept_elem && concept_elem->is_sequence() && !concept_elem->sequence_items().empty()) {
            validate_coded_entry(concept_elem->sequence_items()[0], "Root Concept Name", findings);
        }
    }
 
    // Validate content sequence
    if (options_.validate_content_sequence) {
        validate_content_sequence(dataset, findings);
    }
}

References kcenon::pacs::services::validation::sr_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::sr_tags::concept_name_code_sequence, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get(), kcenon::pacs::core::dicom_dataset::get_string(), options_, kcenon::pacs::services::validation::sr_validation_options::validate_coded_entries, validate_coded_entry(), validate_content_sequence(), kcenon::pacs::services::validation::sr_validation_options::validate_content_sequence, kcenon::pacs::services::validation::sr_validation_options::validate_value_types, and kcenon::pacs::services::validation::sr_tags::value_type.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_sr_document_general_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_sr_document_general_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 404 of file sr_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, sr_tags::instance_number, "InstanceNumber", findings);
        check_type1_attribute(dataset, sr_tags::completion_flag, "CompletionFlag", findings);
        check_type1_attribute(dataset, sr_tags::verification_flag, "VerificationFlag", findings);
    }
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, sr_tags::content_date, "ContentDate", findings);
        check_type2_attribute(dataset, sr_tags::content_time, "ContentTime", findings);
    }
 
    // Validate flag values
    if (options_.validate_document_status) {
        check_completion_flag(dataset, findings);
        check_verification_flag(dataset, findings);
    }
 
    // VerifyingObserverSequence is Type 1C - required if VerificationFlag is VERIFIED
    if (options_.check_conditional && dataset.contains(sr_tags::verification_flag)) {
        auto flag = dataset.get_string(sr_tags::verification_flag);
        if (flag == "VERIFIED" && !dataset.contains(sr_tags::verifying_observer_sequence)) {
            findings.push_back({
                validation_severity::error,
                sr_tags::verifying_observer_sequence,
                "VerifyingObserverSequence is required when VerificationFlag is VERIFIED",
                "SR-DOC-ERR-001"
            });
        }
    }
}

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_sr_document_series_module()

void kcenon::pacs::services::validation::sr_iod_validator::validate_sr_document_series_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 379 of file sr_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::modality, "Modality", findings);
        check_type1_attribute(dataset, tags::series_instance_uid, "SeriesInstanceUID", findings);
        check_modality(dataset, findings);
    }
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, tags::series_number, "SeriesNumber", findings);
    }
}

References check_modality(), kcenon::pacs::services::validation::sr_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::sr_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::core::tags::modality, options_, kcenon::pacs::core::tags::series_instance_uid, and kcenon::pacs::core::tags::series_number.

Referenced by validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), and validate_key_object_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_text_content_item()

void kcenon::pacs::services::validation::sr_iod_validator::validate_text_content_item	(	const core::dicom_dataset &	item,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 674 of file sr_iod_validator.cpp.

                                                   {
 
    if (!item.contains(sr_tags::text_value)) {
        findings.push_back({
            validation_severity::error,
            sr_tags::text_value,
            "TextValue is required for TEXT content item",
            "SR-TEXT-ERR-001"
        });
    }
}

References kcenon::pacs::services::validation::error, and kcenon::pacs::services::validation::sr_tags::text_value.

Referenced by validate_content_item().

Here is the caller graph for this function:

Member Data Documentation

◆ options_

sr_validation_options kcenon::pacs::services::validation::sr_iod_validator::options_

private

Definition at line 318 of file sr_iod_validator.h.

Referenced by options(), set_options(), validate_basic_text_sr(), validate_comprehensive_sr(), validate_enhanced_sr(), validate_general_equipment_module(), validate_general_study_module(), validate_key_object_selection(), validate_patient_module(), validate_sop_common_module(), validate_sr_document_content_module(), validate_sr_document_general_module(), and validate_sr_document_series_module().

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

include/kcenon/pacs/services/validation/sr_iod_validator.h
src/services/validation/sr_iod_validator.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Validated Modules

Common Modules (All SR Types)

Enhanced SR Additional Modules

Comprehensive SR Additional Modules

Constructor & Destructor Documentation

◆ sr_iod_validator() [1/2]

◆ sr_iod_validator() [2/2]

Member Function Documentation

◆ check_completion_flag()

◆ check_modality()

◆ check_type1_attribute()

◆ check_type2_attribute()

◆ check_verification_flag()

◆ options()

◆ quick_check()

◆ set_options()

◆ validate()

◆ validate_basic_text_sr()

◆ validate_code_content_item()

◆ validate_coded_entry()

◆ validate_comprehensive_sr()

◆ validate_content_item()

◆ validate_content_sequence()

◆ validate_content_tree()

◆ validate_enhanced_sr()

◆ validate_evidence_sequences()

◆ validate_general_equipment_module()

◆ validate_general_study_module()

◆ validate_image_content_item()

◆ validate_key_object_selection()

◆ validate_num_content_item()

◆ validate_patient_module()

◆ validate_references()

◆ validate_scoord3d_content_item()

◆ validate_scoord_content_item()

◆ validate_sop_common_module()

◆ validate_sr_document_content_module()

◆ validate_sr_document_general_module()

◆ validate_sr_document_series_module()

◆ validate_text_content_item()

Member Data Documentation

◆ options_