Validator for Segmentation IODs. More...

#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

Validator for Segmentation IODs.

Validates DICOM datasets against the Segmentation IOD specification. Checks required modules, attributes, segment sequences, and value constraints.

Validated Modules

Mandatory Modules

Patient Module (M)
Clinical Trial Subject Module (U)
General Study Module (M)
Patient Study Module (U)
General Series Module (M)
Segmentation Series Module (M)
General Equipment Module (M)
Enhanced General Equipment Module (M)
General Image Module (M)
Image Pixel Module (M)
Segmentation Image Module (M)
Multi-frame Functional Groups Module (M)
Multi-frame Dimension Module (M)
Specimen Module (U)
Common Instance Reference Module (M)
SOP Common Module (M)

Example:: seg_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::seg_iod_validator
Validator for Segmentation IODs.
Definition seg_iod_validator.h:112

kcenon::pacs::services::validation::seg_iod_validator::validate
validation_result validate(const core::dicom_dataset &dataset) const
Validate a DICOM dataset against SEG IOD.
Definition seg_iod_validator.cpp:84

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.

◆ 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

kcenon::pacs::services::validation::seg_iod_validator::options

const seg_validation_options & options() const noexcept

Get the validation options.

Definition seg_iod_validator.cpp:195

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Validated Modules

Mandatory Modules

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_