#include <seg_iod_validator.h>

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

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

	seg_iod_validator (const seg_validation_options &options)
	Construct validator with custom options.

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

validation_result	validate_segments (const core::dicom_dataset &dataset) const
	Validate segment sequence completeness.

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 seg_validation_options &	options () const noexcept
	Get the validation options.

void	set_options (const seg_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_general_series_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

void	validate_segmentation_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_enhanced_general_equipment_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

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

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

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

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

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

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

void	validate_common_instance_reference_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	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_segmentation_type (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

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

void	validate_single_segment (const core::dicom_dataset &segment_item, size_t segment_index, std::vector< validation_finding > &findings) const

Private Attributes
seg_validation_options	options_

Detailed Description

Definition at line 112 of file seg_iod_validator.h.

Constructor & Destructor Documentation

◆ seg_iod_validator() [1/2]

kcenon::pacs::services::validation::seg_iod_validator::seg_iod_validator ( )

default

Construct validator with default options.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

◆ seg_iod_validator() [2/2]

kcenon::pacs::services::validation::seg_iod_validator::seg_iod_validator ( const seg_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options Validation options

Definition at line 81 of file seg_iod_validator.cpp.

82 : options_(options) {}

kcenon::pacs::services::validation::seg_iod_validator::options_

seg_validation_options options_

Definition seg_iod_validator.h:263

Member Function Documentation

◆ check_modality()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 591 of file seg_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::modality)) {
        return;  // Already reported
    }
 
    auto modality = dataset.get_string(tags::modality);
    if (modality != "SEG") {
        findings.push_back({
            validation_severity::error,
            tags::modality,
            "Modality must be 'SEG' for Segmentation objects, found: " + modality,
            "SEG-ERR-001"
        });
    }
}

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_general_series_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_pixel_data_consistency()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 629 of file seg_iod_validator.cpp.

                                                   {
 
    // For SEG, SamplesPerPixel must be 1
    auto samples = dataset.get_numeric<uint16_t>(tags::samples_per_pixel);
    if (samples && *samples != 1) {
        findings.push_back({
            validation_severity::error,
            tags::samples_per_pixel,
            "SamplesPerPixel must be 1 for Segmentation objects",
            "SEG-PXL-ERR-001"
        });
    }
 
    // PhotometricInterpretation must be MONOCHROME2
    if (dataset.contains(tags::photometric_interpretation)) {
        auto photometric = dataset.get_string(tags::photometric_interpretation);
        if (photometric != "MONOCHROME2") {
            findings.push_back({
                validation_severity::error,
                tags::photometric_interpretation,
                "PhotometricInterpretation must be MONOCHROME2 for Segmentation",
                "SEG-PXL-ERR-002"
            });
        }
    }
 
    // Check BitsAllocated based on SegmentationType
    auto bits_allocated = dataset.get_numeric<uint16_t>(tags::bits_allocated);
    auto seg_type = dataset.get_string(seg_tags::segmentation_type);
 
    if (bits_allocated && !seg_type.empty()) {
        if (seg_type == "BINARY" && *bits_allocated != 1) {
            findings.push_back({
                validation_severity::warning,
                tags::bits_allocated,
                "BitsAllocated is typically 1 for BINARY segmentation, found: " +
                std::to_string(*bits_allocated),
                "SEG-PXL-WARN-001"
            });
        }
 
        if (seg_type == "FRACTIONAL" && *bits_allocated != 8) {
            findings.push_back({
                validation_severity::warning,
                tags::bits_allocated,
                "BitsAllocated is typically 8 for FRACTIONAL segmentation, found: " +
                std::to_string(*bits_allocated),
                "SEG-PXL-WARN-002"
            });
        }
    }
}

References kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::tags::photometric_interpretation, kcenon::pacs::core::tags::samples_per_pixel, kcenon::pacs::services::validation::seg_tags::segmentation_type, and kcenon::pacs::services::validation::warning.

Referenced by validate_image_pixel_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_segmentation_type()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 610 of file seg_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(seg_tags::segmentation_type)) {
        return;  // Already reported
    }
 
    auto seg_type = dataset.get_string(seg_tags::segmentation_type);
    if (!sop_classes::is_valid_segmentation_type(seg_type)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segmentation_type,
            "Invalid SegmentationType value: " + seg_type + " (must be BINARY or FRACTIONAL)",
            "SEG-ERR-006"
        });
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::is_valid_segmentation_type(), and kcenon::pacs::services::validation::seg_tags::segmentation_type.

Referenced by validate_segmentation_image_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::seg_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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 529 of file seg_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() + ")",
            "SEG-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() + ")",
                        "SEG-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() + ")",
                        "SEG-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_enhanced_general_equipment_module(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_multiframe_dimension_module(), validate_multiframe_functional_groups_module(), validate_segmentation_image_module(), and validate_sop_common_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::seg_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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 574 of file seg_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() + ")",
            "SEG-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_image_module(), validate_general_series_module(), validate_general_study_module(), and validate_patient_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ options()

const seg_validation_options & kcenon::pacs::services::validation::seg_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 195 of file seg_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::seg_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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 166 of file seg_iod_validator.cpp.

                                                                      {
    // Check essential Type 1 attributes for SEG
 
    // 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 SEG
    auto modality = dataset.get_string(tags::modality);
    if (modality != "SEG") return false;
 
    // Segmentation Image Module
    if (!dataset.contains(seg_tags::segmentation_type)) return false;
    if (!dataset.contains(seg_tags::segment_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 SEG
    auto sop_class = dataset.get_string(tags::sop_class_uid);
    if (!sop_classes::is_seg_storage_sop_class(sop_class)) return false;
 
    return true;
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::is_seg_storage_sop_class(), kcenon::pacs::core::tags::modality, kcenon::pacs::services::validation::seg_tags::segment_sequence, kcenon::pacs::services::validation::seg_tags::segmentation_type, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_options()

void kcenon::pacs::services::validation::seg_iod_validator::set_options ( const seg_validation_options & options )

Set validation options.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 199 of file seg_iod_validator.cpp.

                                                                         {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

◆ validate()

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

nodiscard

Validate a DICOM dataset against SEG IOD.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 84 of file seg_iod_validator.cpp.

                                                                                {
    validation_result result;
    result.is_valid = true;
 
    // Validate mandatory modules
    if (options_.check_type1 || options_.check_type2) {
        validate_patient_module(dataset, result.findings);
        validate_general_study_module(dataset, result.findings);
        validate_general_series_module(dataset, result.findings);
        validate_segmentation_series_module(dataset, result.findings);
        validate_general_equipment_module(dataset, result.findings);
        validate_enhanced_general_equipment_module(dataset, result.findings);
        validate_general_image_module(dataset, result.findings);
        validate_segmentation_image_module(dataset, result.findings);
        validate_sop_common_module(dataset, result.findings);
    }
 
    if (options_.validate_segment_sequence) {
        validate_segment_sequence(dataset, result.findings);
    }
 
    if (options_.validate_pixel_data) {
        validate_image_pixel_module(dataset, result.findings);
    }
 
    if (options_.validate_references) {
        validate_common_instance_reference_module(dataset, result.findings);
    }
 
    // Multi-frame validation
    validate_multiframe_functional_groups_module(dataset, result.findings);
    validate_multiframe_dimension_module(dataset, result.findings);
 
    // Check for errors
    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 kcenon::pacs::services::validation::validate_seg_iod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_common_instance_reference_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 485 of file seg_iod_validator.cpp.

                                                   {
 
    // Referenced Series Sequence is Type 1C - required if references exist
    if (options_.check_conditional) {
        if (!dataset.contains(seg_tags::referenced_series_sequence_cir)) {
            findings.push_back({
                validation_severity::warning,
                seg_tags::referenced_series_sequence_cir,
                "ReferencedSeriesSequence (0008,1115) should be present for source image references",
                "SEG-REF-WARN-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_conditional, kcenon::pacs::core::dicom_dataset::contains(), options_, kcenon::pacs::services::validation::seg_tags::referenced_series_sequence_cir, and kcenon::pacs::services::validation::warning.

Referenced by validate(), and validate_references().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_enhanced_general_equipment_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 271 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, seg_tags::manufacturer, "Manufacturer", findings);
        check_type1_attribute(dataset, seg_tags::manufacturer_model_name, "ManufacturerModelName", findings);
        check_type1_attribute(dataset, seg_tags::device_serial_number, "DeviceSerialNumber", findings);
        check_type1_attribute(dataset, seg_tags::software_versions, "SoftwareVersions", findings);
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::seg_tags::device_serial_number, kcenon::pacs::services::validation::seg_tags::manufacturer, kcenon::pacs::services::validation::seg_tags::manufacturer_model_name, options_, and kcenon::pacs::services::validation::seg_tags::software_versions.

Referenced by validate().

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::seg_iod_validator::validate_general_equipment_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 262 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, seg_tags::manufacturer, "Manufacturer", findings);
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::services::validation::seg_tags::manufacturer, and options_.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_general_image_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 283 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type2) {
        constexpr dicom_tag instance_number{0x0020, 0x0013};
        check_type2_attribute(dataset, instance_number, "InstanceNumber", findings);
    }
}

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

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_general_series_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 236 of file seg_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);
 
        // Frame of Reference Module - Type 1 for SEG
        check_type1_attribute(dataset, tags::frame_of_reference_uid, "FrameOfReferenceUID", findings);
    }
 
    if (options_.check_type2) {
        check_type2_attribute(dataset, tags::series_number, "SeriesNumber", findings);
    }
}

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

Referenced by validate().

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::seg_iod_validator::validate_general_study_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 219 of file seg_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::seg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::seg_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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_image_pixel_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 293 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::samples_per_pixel, "SamplesPerPixel", findings);
        check_type1_attribute(dataset, tags::photometric_interpretation, "PhotometricInterpretation", findings);
        check_type1_attribute(dataset, tags::rows, "Rows", findings);
        check_type1_attribute(dataset, tags::columns, "Columns", findings);
        check_type1_attribute(dataset, tags::bits_allocated, "BitsAllocated", findings);
        check_type1_attribute(dataset, tags::bits_stored, "BitsStored", findings);
        check_type1_attribute(dataset, tags::high_bit, "HighBit", findings);
        check_type1_attribute(dataset, tags::pixel_representation, "PixelRepresentation", findings);
    }
 
    // SEG-specific pixel data constraints
    check_pixel_data_consistency(dataset, findings);
}

References kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::core::tags::bits_stored, check_pixel_data_consistency(), kcenon::pacs::services::validation::seg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::core::tags::columns, kcenon::pacs::core::tags::high_bit, options_, kcenon::pacs::core::tags::photometric_interpretation, kcenon::pacs::core::tags::pixel_representation, kcenon::pacs::core::tags::rows, and kcenon::pacs::core::tags::samples_per_pixel.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_multiframe_dimension_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 473 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, seg_tags::dimension_organization_sequence,
                             "DimensionOrganizationSequence", findings);
        check_type1_attribute(dataset, seg_tags::dimension_index_sequence,
                             "DimensionIndexSequence", findings);
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::seg_tags::dimension_index_sequence, kcenon::pacs::services::validation::seg_tags::dimension_organization_sequence, and options_.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_multiframe_functional_groups_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 460 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, seg_tags::number_of_frames, "NumberOfFrames", findings);
        check_type1_attribute(dataset, seg_tags::shared_functional_groups_sequence,
                             "SharedFunctionalGroupsSequence", findings);
        check_type1_attribute(dataset, seg_tags::per_frame_functional_groups_sequence,
                             "PerFrameFunctionalGroupsSequence", findings);
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::seg_tags::number_of_frames, options_, kcenon::pacs::services::validation::seg_tags::per_frame_functional_groups_sequence, and kcenon::pacs::services::validation::seg_tags::shared_functional_groups_sequence.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_patient_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 207 of file seg_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::seg_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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_references()

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

nodiscard

Validate referenced instances.

Checks that all referenced series and instances are properly specified.

Parameters

dataset The dataset to validate

Returns: Validation result for references

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 150 of file seg_iod_validator.cpp.

                                                                         {
    validation_result result;
    result.is_valid = true;
 
    validate_common_instance_reference_module(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_common_instance_reference_module().

Here is the call graph for this function:

◆ validate_segment_sequence()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 352 of file seg_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(seg_tags::segment_sequence)) {
        // Already reported as Type 1 missing
        return;
    }
 
    // Get sequence items
    const auto* element = dataset.get(seg_tags::segment_sequence);
    if (!element || !element->is_sequence() || element->sequence_items().empty()) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segment_sequence,
            "SegmentSequence must contain at least one segment",
            "SEG-ERR-004"
        });
        return;
    }
 
    // Validate each segment
    const auto& sequence = element->sequence_items();
    for (size_t i = 0; i < sequence.size(); ++i) {
        const auto& segment_item = sequence[i];
        validate_single_segment(segment_item, i, findings);
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get(), kcenon::pacs::services::validation::seg_tags::segment_sequence, and validate_single_segment().

Referenced by validate(), and validate_segments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_segmentation_image_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 312 of file seg_iod_validator.cpp.

                                                   {
 
    if (options_.check_type1) {
        check_type1_attribute(dataset, seg_tags::segmentation_type, "SegmentationType", findings);
        check_type1_attribute(dataset, seg_tags::segment_sequence, "SegmentSequence", findings);
    }
 
    // Validate segmentation type value
    check_segmentation_type(dataset, findings);
 
    // Check conditional attributes based on segmentation type
    if (options_.check_conditional && dataset.contains(seg_tags::segmentation_type)) {
        auto seg_type = dataset.get_string(seg_tags::segmentation_type);
 
        if (seg_type == "FRACTIONAL") {
            // MaxFractionalValue is Type 1 for FRACTIONAL
            if (!dataset.contains(seg_tags::max_fractional_value)) {
                findings.push_back({
                    validation_severity::error,
                    seg_tags::max_fractional_value,
                    "MaxFractionalValue (0062,000E) is required when SegmentationType is FRACTIONAL",
                    "SEG-ERR-002"
                });
            }
 
            // SegmentationFractionalType is Type 1 for FRACTIONAL
            if (!dataset.contains(seg_tags::segmentation_fractional_type)) {
                findings.push_back({
                    validation_severity::error,
                    seg_tags::segmentation_fractional_type,
                    "SegmentationFractionalType (0062,0010) is required when SegmentationType is FRACTIONAL",
                    "SEG-ERR-003"
                });
            }
        }
    }
}

References kcenon::pacs::services::validation::seg_validation_options::check_conditional, check_segmentation_type(), kcenon::pacs::services::validation::seg_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::validation::seg_tags::max_fractional_value, options_, kcenon::pacs::services::validation::seg_tags::segment_sequence, kcenon::pacs::services::validation::seg_tags::segmentation_fractional_type, and kcenon::pacs::services::validation::seg_tags::segmentation_type.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_segmentation_series_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 254 of file seg_iod_validator.cpp.

                                                                    {
 
    // Modality must be "SEG" - already checked in general series validation
    // This module primarily constrains Modality to SEG
}

Referenced by validate().

Here is the caller graph for this function:

◆ validate_segments()

validation_result kcenon::pacs::services::validation::seg_iod_validator::validate_segments ( const core::dicom_dataset & dataset ) const

nodiscard

Validate segment sequence completeness.

Checks that all segments are properly defined with required attributes.

Parameters

dataset The dataset to validate

Returns: Validation result for segment sequence

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 133 of file seg_iod_validator.cpp.

                                                                       {
    validation_result result;
    result.is_valid = true;
 
    validate_segment_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_segment_sequence().

Here is the call graph for this function:

◆ validate_single_segment()

void kcenon::pacs::services::validation::seg_iod_validator::validate_single_segment	(	const core::dicom_dataset &	segment_item,
		size_t	segment_index,
		std::vector< validation_finding > &	findings ) const

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 381 of file seg_iod_validator.cpp.

                                                   {
 
    std::string prefix = "Segment[" + std::to_string(segment_index) + "]: ";
 
    // Type 1 attributes within segment
    if (!segment_item.contains(seg_tags::segment_number)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segment_number,
            prefix + "SegmentNumber (0062,0004) is required",
            "SEG-SEQ-ERR-001"
        });
    }
 
    if (!segment_item.contains(seg_tags::segment_label)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segment_label,
            prefix + "SegmentLabel (0062,0005) is required",
            "SEG-SEQ-ERR-002"
        });
    }
 
    if (!segment_item.contains(seg_tags::segment_algorithm_type)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segment_algorithm_type,
            prefix + "SegmentAlgorithmType (0062,0008) is required",
            "SEG-SEQ-ERR-003"
        });
    } else if (options_.validate_algorithm_info) {
        auto algo_type = segment_item.get_string(seg_tags::segment_algorithm_type);
        if (!sop_classes::is_valid_segment_algorithm_type(algo_type)) {
            findings.push_back({
                validation_severity::warning,
                seg_tags::segment_algorithm_type,
                prefix + "Invalid SegmentAlgorithmType value: " + algo_type,
                "SEG-SEQ-WARN-001"
            });
        }
    }
 
    // Segmented Property Category Code Sequence is Type 1
    if (!segment_item.contains(seg_tags::segmented_property_category_code_sequence)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segmented_property_category_code_sequence,
            prefix + "SegmentedPropertyCategoryCodeSequence (0062,0003) is required",
            "SEG-SEQ-ERR-004"
        });
    }
 
    // Segmented Property Type Code Sequence is Type 1
    if (!segment_item.contains(seg_tags::segmented_property_type_code_sequence)) {
        findings.push_back({
            validation_severity::error,
            seg_tags::segmented_property_type_code_sequence,
            prefix + "SegmentedPropertyTypeCodeSequence (0062,000F) is required",
            "SEG-SEQ-ERR-005"
        });
    }
 
    // Validate segment label is not empty
    if (options_.validate_segment_labels && segment_item.contains(seg_tags::segment_label)) {
        auto label = segment_item.get_string(seg_tags::segment_label);
        if (label.empty()) {
            findings.push_back({
                validation_severity::warning,
                seg_tags::segment_label,
                prefix + "SegmentLabel should not be empty",
                "SEG-SEQ-WARN-002"
            });
        }
    }
}

Referenced by validate_segment_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_sop_common_module()

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

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 502 of file seg_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 a SEG storage class
    if (dataset.contains(tags::sop_class_uid)) {
        auto sop_class = dataset.get_string(tags::sop_class_uid);
        if (!sop_classes::is_seg_storage_sop_class(sop_class)) {
            findings.push_back({
                validation_severity::error,
                tags::sop_class_uid,
                "SOPClassUID is not a recognized SEG Storage SOP Class: " + sop_class,
                "SEG-ERR-005"
            });
        }
    }
}

References kcenon::pacs::services::validation::seg_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_seg_storage_sop_class(), options_, kcenon::pacs::core::tags::sop_class_uid, and kcenon::pacs::core::tags::sop_instance_uid.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ options_

seg_validation_options kcenon::pacs::services::validation::seg_iod_validator::options_

private

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/validation/seg_iod_validator.h.

Definition at line 263 of file seg_iod_validator.h.

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ seg_iod_validator() [1/2]

◆ seg_iod_validator() [2/2]

Member Function Documentation

◆ check_modality()

◆ check_pixel_data_consistency()

◆ check_segmentation_type()

◆ check_type1_attribute()

◆ check_type2_attribute()

◆ options()

◆ quick_check()

◆ set_options()

◆ validate()

◆ validate_common_instance_reference_module()

◆ validate_enhanced_general_equipment_module()

◆ validate_general_equipment_module()

◆ validate_general_image_module()

◆ validate_general_series_module()

◆ validate_general_study_module()

◆ validate_image_pixel_module()

◆ validate_multiframe_dimension_module()

◆ validate_multiframe_functional_groups_module()

◆ validate_patient_module()

◆ validate_references()

◆ validate_segment_sequence()

◆ validate_segmentation_image_module()

◆ validate_segmentation_series_module()

◆ validate_segments()

◆ validate_single_segment()

◆ validate_sop_common_module()

Member Data Documentation

◆ options_