kcenon::pacs::services::validation::dx_iod_validator Class Reference

Validator for Digital X-Ray Image IODs. More...

#include <dx_iod_validator.h>

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

Public Member Functions
	dx_iod_validator ()=default
	Construct validator with default options.
	dx_iod_validator (const dx_validation_options &options)
	Construct validator with custom options.
validation_result	validate (const core::dicom_dataset &dataset) const
	Validate a DICOM dataset against DX IOD.
validation_result	validate_for_presentation (const core::dicom_dataset &dataset) const
	Validate a For Presentation DX dataset.
validation_result	validate_for_processing (const core::dicom_dataset &dataset) const
	Validate a For Processing DX dataset.
bool	quick_check (const core::dicom_dataset &dataset) const
	Quick check if dataset has minimum required attributes.
const dx_validation_options &	options () const noexcept
	Get the validation options.
void	set_options (const dx_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_dx_anatomy_imaged_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const
void	validate_dx_image_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const
void	validate_dx_detector_module (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const
void	validate_dx_positioning_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_voi_lut_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_pixel_data_consistency (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const
void	check_photometric_interpretation (const core::dicom_dataset &dataset, std::vector< validation_finding > &findings) const

Private Attributes
dx_validation_options	options_

Detailed Description

Validator for Digital X-Ray Image IODs.

Validates DICOM datasets against the DX Image IOD specification. Checks required modules, attributes, and value constraints specific to digital radiography.

Validated Modules

Mandatory Modules (M)

• Patient Module
• General Study Module
• Patient Study Module
• General Series Module
• General Equipment Module
• General Image Module
• Image Pixel Module
• DX Anatomy Imaged Module
• DX Image Module
• DX Detector Module
• SOP Common Module

Conditional Modules (C)

• DX Positioning Module (required if view position is specified)
• VOI LUT Module (For Presentation images)

Example:

dx_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";
    }
}

Definition at line 116 of file dx_iod_validator.h.

Constructor & Destructor Documentation

dx_iod_validator() [1/2]

kcenon::pacs::services::validation::dx_iod_validator::dx_iod_validator ( )

default

Construct validator with default options.

dx_iod_validator() [2/2]

kcenon::pacs::services::validation::dx_iod_validator::dx_iod_validator ( const dx_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options

Validation options

Definition at line 66 of file dx_iod_validator.cpp.

    : options_(options) {}

Member Function Documentation

check_modality()

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

private

Definition at line 573 of file dx_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::modality)) {
        return;  // Already reported as Type 1 missing
    }
 
    auto modality = dataset.get_string(tags::modality);
    if (modality != "DX") {
        findings.push_back({
            validation_severity::error,
            tags::modality,
            "Modality must be 'DX' for digital X-ray images, found: " + modality,
            "DX-ERR-002"
        });
    }
}

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

Referenced by validate_general_series_module().

Here is the call graph for this function:

Here is the caller graph for this function:

check_photometric_interpretation()

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

private

Definition at line 651 of file dx_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::photometric_interpretation)) {
        return;  // Already reported as missing
    }
 
    auto photometric = dataset.get_string(tags::photometric_interpretation);
    if (!sop_classes::is_valid_dx_photometric(photometric)) {
        findings.push_back({
            validation_severity::error,
            tags::photometric_interpretation,
            "DX images must use MONOCHROME1 or MONOCHROME2, found: " + photometric,
            "DX-ERR-007"
        });
    }
}

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_dx_photometric(), and kcenon::pacs::core::tags::photometric_interpretation.

Referenced by validate_image_pixel_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::dx_iod_validator::check_pixel_data_consistency ( const core::dicom_dataset & dataset, std::vector< validation_finding > & findings ) const

private

Definition at line 592 of file dx_iod_validator.cpp.

                                                   {
 
    // Check BitsStored <= BitsAllocated
    auto bits_allocated = dataset.get_numeric<uint16_t>(tags::bits_allocated);
    auto bits_stored = dataset.get_numeric<uint16_t>(tags::bits_stored);
    auto high_bit = dataset.get_numeric<uint16_t>(tags::high_bit);
 
    if (bits_allocated && bits_stored) {
        if (*bits_stored > *bits_allocated) {
            findings.push_back({
                validation_severity::error,
                tags::bits_stored,
                "BitsStored (" + std::to_string(*bits_stored) +
                ") exceeds BitsAllocated (" + std::to_string(*bits_allocated) + ")",
                "DX-ERR-005"
            });
        }
 
        // DX typically uses 10-16 bits stored
        if (*bits_stored < 10 || *bits_stored > 16) {
            findings.push_back({
                validation_severity::info,
                tags::bits_stored,
                "DX images typically use 10-16 bits, found: " +
                std::to_string(*bits_stored),
                "DX-INFO-003"
            });
        }
    }
 
    // Check HighBit == BitsStored - 1
    if (bits_stored && high_bit) {
        if (*high_bit != *bits_stored - 1) {
            findings.push_back({
                validation_severity::warning,
                tags::high_bit,
                "HighBit (" + std::to_string(*high_bit) +
                ") should typically be BitsStored - 1 (" +
                std::to_string(*bits_stored - 1) + ")",
                "DX-WARN-007"
            });
        }
    }
 
    // DX must be grayscale - check SamplesPerPixel
    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,
            "DX images must be grayscale (SamplesPerPixel = 1), found: " +
            std::to_string(*samples),
            "DX-ERR-006"
        });
    }
}

References kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::core::tags::bits_stored, kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::core::tags::high_bit, kcenon::pacs::services::validation::info, kcenon::pacs::core::tags::samples_per_pixel, 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_type1_attribute()

void kcenon::pacs::services::validation::dx_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 526 of file dx_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() + ")",
            "DX-TYPE1-MISSING"
        });
    } else {
        // Type 1 must have a value (cannot be 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() + ")",
                "DX-TYPE1-EMPTY"
            });
        }
    }
}

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

Referenced by validate_dx_detector_module(), validate_dx_image_module(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_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::dx_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 555 of file dx_iod_validator.cpp.

                                                   {
 
    // Type 2 must be present but can be empty
    if (!dataset.contains(tag)) {
        findings.push_back({
            validation_severity::warning,
            tag,
            std::string("Type 2 attribute missing: ") + std::string(name) +
            " (" + tag.to_string() + ")",
            "DX-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_dx_anatomy_imaged_module(), validate_dx_detector_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 dx_validation_options & kcenon::pacs::services::validation::dx_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Definition at line 222 of file dx_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::dx_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 critical Type 1 attributes.

Parameters

dataset

The dataset to check

Returns

true if all critical Type 1 attributes are present

Definition at line 190 of file dx_iod_validator.cpp.

                                                                     {
    // Check only critical Type 1 attributes for quick validation
 
    // General Study Module Type 1
    if (!dataset.contains(tags::study_instance_uid)) return false;
 
    // General Series Module Type 1
    if (!dataset.contains(tags::modality)) return false;
    if (!dataset.contains(tags::series_instance_uid)) return false;
 
    // Check modality is DX
    auto modality = dataset.get_string(tags::modality);
    if (modality != "DX") return false;
 
    // Image Pixel Module Type 1
    if (!dataset.contains(tags::samples_per_pixel)) return false;
    if (!dataset.contains(tags::photometric_interpretation)) return false;
    if (!dataset.contains(tags::rows)) return false;
    if (!dataset.contains(tags::columns)) return false;
    if (!dataset.contains(tags::bits_allocated)) return false;
    if (!dataset.contains(tags::bits_stored)) return false;
    if (!dataset.contains(tags::high_bit)) return false;
    if (!dataset.contains(tags::pixel_representation)) return false;
    if (!dataset.contains(tags::pixel_data)) return false;
 
    // SOP Common Module Type 1
    if (!dataset.contains(tags::sop_class_uid)) return false;
    if (!dataset.contains(tags::sop_instance_uid)) return false;
 
    return true;
}

References kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::core::tags::bits_stored, kcenon::pacs::core::tags::columns, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::tags::high_bit, kcenon::pacs::core::tags::modality, kcenon::pacs::core::tags::photometric_interpretation, kcenon::pacs::core::tags::pixel_data, kcenon::pacs::core::tags::pixel_representation, kcenon::pacs::core::tags::rows, kcenon::pacs::core::tags::samples_per_pixel, 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_dx_dataset().

Here is the call graph for this function:

Here is the caller graph for this function:

set_options()

void kcenon::pacs::services::validation::dx_iod_validator::set_options

(

const dx_validation_options &

options

)

Set validation options.

Definition at line 226 of file dx_iod_validator.cpp.

                                                                       {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

validate()

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

nodiscard

Validate a DICOM dataset against DX IOD.

Performs comprehensive validation including patient, study, series, image, and DX-specific modules.

Parameters

dataset

The dataset to validate

Returns

Validation result with all findings

Definition at line 69 of file dx_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_sop_common_module(dataset, result.findings);
    }
 
    if (options_.validate_pixel_data) {
        validate_image_pixel_module(dataset, result.findings);
    }
 
    if (options_.validate_dx_specific) {
        validate_dx_image_module(dataset, result.findings);
        validate_dx_detector_module(dataset, result.findings);
    }
 
    if (options_.validate_anatomy) {
        validate_dx_anatomy_imaged_module(dataset, result.findings);
        validate_dx_positioning_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;
}

References kcenon::pacs::services::validation::dx_validation_options::check_type1, kcenon::pacs::services::validation::dx_validation_options::check_type2, kcenon::pacs::services::validation::error, kcenon::pacs::services::validation::validation_result::findings, kcenon::pacs::services::validation::validation_result::is_valid, options_, kcenon::pacs::services::validation::dx_validation_options::strict_mode, kcenon::pacs::services::validation::dx_validation_options::validate_anatomy, validate_dx_anatomy_imaged_module(), validate_dx_detector_module(), validate_dx_image_module(), validate_dx_positioning_module(), kcenon::pacs::services::validation::dx_validation_options::validate_dx_specific, validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_patient_module(), kcenon::pacs::services::validation::dx_validation_options::validate_pixel_data, validate_sop_common_module(), and kcenon::pacs::services::validation::warning.

Referenced by kcenon::pacs::services::validation::validate_dx_iod(), validate_for_presentation(), and validate_for_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_dx_anatomy_imaged_module()

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

private

Definition at line 285 of file dx_iod_validator.cpp.

                                                   {
 
    // Body Part Examined (0018,0015) - Type 2
    if (options_.check_type2) {
        check_type2_attribute(dataset, dx_tags::body_part_examined, "BodyPartExamined", findings);
    }
 
    // Anatomic Region Sequence (0008,2218) - Type 1C
    // Required if Body Part Examined is not sufficient to describe the anatomy
    if (options_.check_conditional) {
        if (!dataset.contains(dx_tags::body_part_examined) &&
            !dataset.contains(dx_tags::anatomic_region_sequence)) {
            findings.push_back({
                validation_severity::warning,
                dx_tags::anatomic_region_sequence,
                "Neither Body Part Examined nor Anatomic Region Sequence present - "
                "anatomy information may be insufficient for clinical use",
                "DX-WARN-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::dx_tags::anatomic_region_sequence, kcenon::pacs::services::validation::dx_tags::body_part_examined, kcenon::pacs::services::validation::dx_validation_options::check_conditional, kcenon::pacs::services::validation::dx_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::core::dicom_dataset::contains(), options_, and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_dx_detector_module()

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

private

Definition at line 385 of file dx_iod_validator.cpp.

                                                   {
 
    // Detector Type (0018,7004) - Type 2
    if (options_.check_type2) {
        check_type2_attribute(dataset, dx_tags::detector_type, "DetectorType", findings);
 
        if (dataset.contains(dx_tags::detector_type)) {
            auto type = dataset.get_string(dx_tags::detector_type);
            if (type != "DIRECT" && type != "SCINTILLATOR" &&
                type != "STORAGE" && type != "FILM") {
                findings.push_back({
                    validation_severity::warning,
                    dx_tags::detector_type,
                    "Unusual Detector Type for DX: " + type,
                    "DX-WARN-004"
                });
            }
        }
    }
 
    // Imager Pixel Spacing (0018,1164) - Type 1 for DX
    if (options_.check_type1) {
        check_type1_attribute(dataset, dx_tags::imager_pixel_spacing,
                              "ImagerPixelSpacing", findings);
    }
}

References kcenon::pacs::services::validation::dx_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::dx_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::dx_tags::detector_type, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::dx_tags::imager_pixel_spacing, options_, and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_dx_image_module()

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

private

Definition at line 310 of file dx_iod_validator.cpp.

                                                   {
 
    // Image Type (0008,0008) - Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, dx_tags::image_type, "ImageType", findings);
 
        // Validate Image Type values for DX
        if (dataset.contains(dx_tags::image_type)) {
            auto image_type = dataset.get_string(dx_tags::image_type);
            // First value should be ORIGINAL or DERIVED
            if (image_type.find("ORIGINAL") == std::string::npos &&
                image_type.find("DERIVED") == std::string::npos) {
                findings.push_back({
                    validation_severity::warning,
                    dx_tags::image_type,
                    "Image Type first value should be ORIGINAL or DERIVED",
                    "DX-WARN-002"
                });
            }
            // Second value should be PRIMARY or SECONDARY
            if (image_type.find("PRIMARY") == std::string::npos &&
                image_type.find("SECONDARY") == std::string::npos) {
                findings.push_back({
                    validation_severity::warning,
                    dx_tags::image_type,
                    "Image Type second value should be PRIMARY or SECONDARY",
                    "DX-WARN-003"
                });
            }
        }
    }
 
    // Acquisition Device Processing Description (0018,1400) - Type 3
    // No validation required, but informational if missing for presentation images
 
    // Pixel Intensity Relationship (0028,1040) - Type 1 for DX
    if (options_.check_type1) {
        check_type1_attribute(dataset, dx_tags::pixel_intensity_relationship,
                              "PixelIntensityRelationship", findings);
 
        if (dataset.contains(dx_tags::pixel_intensity_relationship)) {
            auto relationship = dataset.get_string(dx_tags::pixel_intensity_relationship);
            if (relationship != "LIN" && relationship != "LOG") {
                findings.push_back({
                    validation_severity::error,
                    dx_tags::pixel_intensity_relationship,
                    "Pixel Intensity Relationship must be LIN or LOG, found: " + relationship,
                    "DX-ERR-003"
                });
            }
        }
    }
 
    // Pixel Intensity Relationship Sign (0028,1041) - Type 1 for DX
    if (options_.check_type1) {
        check_type1_attribute(dataset, dx_tags::pixel_intensity_relationship_sign,
                              "PixelIntensityRelationshipSign", findings);
 
        if (dataset.contains(dx_tags::pixel_intensity_relationship_sign)) {
            auto sign = dataset.get_numeric<int16_t>(dx_tags::pixel_intensity_relationship_sign);
            if (sign && *sign != 1 && *sign != -1) {
                findings.push_back({
                    validation_severity::error,
                    dx_tags::pixel_intensity_relationship_sign,
                    "Pixel Intensity Relationship Sign must be 1 or -1, found: " +
                    std::to_string(*sign),
                    "DX-ERR-004"
                });
            }
        }
    }
}

References kcenon::pacs::services::validation::dx_validation_options::check_type1, check_type1_attribute(), 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::services::validation::dx_tags::image_type, options_, kcenon::pacs::services::validation::dx_tags::pixel_intensity_relationship, kcenon::pacs::services::validation::dx_tags::pixel_intensity_relationship_sign, and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_dx_positioning_module()

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

private

Definition at line 414 of file dx_iod_validator.cpp.

                                                   {
 
    // View Position (0018,5101) - Type 2C
    // Required if Patient Orientation (0020,0020) is not present
    if (options_.check_conditional) {
        if (!dataset.contains(dx_tags::patient_orientation) &&
            !dataset.contains(dx_tags::view_position)) {
            findings.push_back({
                validation_severity::warning,
                dx_tags::view_position,
                "Neither Patient Orientation nor View Position present - "
                "image orientation may be unclear",
                "DX-WARN-005"
            });
        }
    }
 
    // Patient Orientation (0020,0020) - Type 2C
    if (options_.check_conditional && dataset.contains(dx_tags::patient_orientation)) {
        auto orientation = dataset.get_string(dx_tags::patient_orientation);
        if (orientation.empty()) {
            findings.push_back({
                validation_severity::info,
                dx_tags::patient_orientation,
                "Patient Orientation is present but empty",
                "DX-INFO-001"
            });
        }
    }
 
    // Distance Source to Detector (0018,1110) - Type 3, but useful for calibration
    // Distance Source to Patient (0018,1111) - Type 3, but useful for calibration
}

References kcenon::pacs::services::validation::dx_validation_options::check_conditional, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::info, options_, kcenon::pacs::services::validation::dx_tags::patient_orientation, kcenon::pacs::services::validation::dx_tags::view_position, and kcenon::pacs::services::validation::warning.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_for_presentation()

validation_result kcenon::pacs::services::validation::dx_iod_validator::validate_for_presentation ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a For Presentation DX dataset.

Performs additional validation for For Presentation specific requirements including VOI LUT and display parameters.

Parameters

dataset

The dataset to validate

Returns

Validation result with all findings

Definition at line 111 of file dx_iod_validator.cpp.

                                                                              {
    auto result = validate(dataset);
 
    // Additional For Presentation validation
    if (options_.validate_presentation_requirements) {
        validate_voi_lut_module(dataset, result.findings);
 
        // Check Presentation Intent Type
        if (dataset.contains(dx_tags::presentation_intent_type)) {
            auto intent = dataset.get_string(dx_tags::presentation_intent_type);
            if (intent != "FOR PRESENTATION") {
                result.findings.push_back({
                    validation_severity::error,
                    dx_tags::presentation_intent_type,
                    "Presentation Intent Type should be 'FOR PRESENTATION' "
                    "for this SOP Class, found: " + intent,
                    "DX-ERR-010"
                });
            }
        }
    }
 
    // Re-check validity
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), options_, kcenon::pacs::services::validation::dx_tags::presentation_intent_type, validate(), kcenon::pacs::services::validation::dx_validation_options::validate_presentation_requirements, and validate_voi_lut_module().

Here is the call graph for this function:

validate_for_processing()

validation_result kcenon::pacs::services::validation::dx_iod_validator::validate_for_processing ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a For Processing DX dataset.

Performs validation for For Processing specific requirements including raw data attributes.

Parameters

dataset

The dataset to validate

Returns

Validation result with all findings

Definition at line 145 of file dx_iod_validator.cpp.

                                                                            {
    auto result = validate(dataset);
 
    // Additional For Processing validation
    if (options_.validate_processing_requirements) {
        // Check Presentation Intent Type
        if (dataset.contains(dx_tags::presentation_intent_type)) {
            auto intent = dataset.get_string(dx_tags::presentation_intent_type);
            if (intent != "FOR PROCESSING") {
                result.findings.push_back({
                    validation_severity::error,
                    dx_tags::presentation_intent_type,
                    "Presentation Intent Type should be 'FOR PROCESSING' "
                    "for this SOP Class, found: " + intent,
                    "DX-ERR-011"
                });
            }
        }
 
        // For Processing images should have linear pixel intensity relationship
        if (dataset.contains(dx_tags::pixel_intensity_relationship)) {
            auto relationship = dataset.get_string(dx_tags::pixel_intensity_relationship);
            if (relationship != "LIN") {
                result.findings.push_back({
                    validation_severity::info,
                    dx_tags::pixel_intensity_relationship,
                    "For Processing images typically have linear (LIN) pixel "
                    "intensity relationship, found: " + relationship,
                    "DX-INFO-002"
                });
            }
        }
    }
 
    // Re-check validity
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::info, options_, kcenon::pacs::services::validation::dx_tags::pixel_intensity_relationship, kcenon::pacs::services::validation::dx_tags::presentation_intent_type, validate(), and kcenon::pacs::services::validation::dx_validation_options::validate_processing_requirements.

Here is the call graph for this function:

validate_general_series_module()

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

private

Definition at line 266 of file dx_iod_validator.cpp.

                                                   {
 
    // Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::modality, "Modality", findings);
        check_type1_attribute(dataset, tags::series_instance_uid, "SeriesInstanceUID", findings);
 
        // Special check: Modality must be "DX"
        check_modality(dataset, findings);
    }
 
    // Type 2
    if (options_.check_type2) {
        check_type2_attribute(dataset, tags::series_number, "SeriesNumber", findings);
    }
}

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

Referenced by validate().

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

private

Definition at line 247 of file dx_iod_validator.cpp.

                                                   {
 
    // Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::study_instance_uid, "StudyInstanceUID", findings);
    }
 
    // Type 2
    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::dx_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::dx_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::dx_iod_validator::validate_image_pixel_module ( const core::dicom_dataset & dataset, std::vector< validation_finding > & findings ) const

private

Definition at line 450 of file dx_iod_validator.cpp.

                                                   {
 
    // Type 1 attributes
    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);
        check_type1_attribute(dataset, tags::pixel_data, "PixelData", findings);
    }
 
    // Validate pixel data consistency
    if (options_.validate_pixel_data) {
        check_pixel_data_consistency(dataset, findings);
        check_photometric_interpretation(dataset, findings);
    }
}

References kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::core::tags::bits_stored, check_photometric_interpretation(), check_pixel_data_consistency(), kcenon::pacs::services::validation::dx_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_data, kcenon::pacs::core::tags::pixel_representation, kcenon::pacs::core::tags::rows, kcenon::pacs::core::tags::samples_per_pixel, and kcenon::pacs::services::validation::dx_validation_options::validate_pixel_data.

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

private

Definition at line 234 of file dx_iod_validator.cpp.

                                                   {
 
    // Patient Module - All attributes are Type 2
    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::dx_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_sop_common_module()

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

private

Definition at line 498 of file dx_iod_validator.cpp.

                                                   {
 
    // Type 1
    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 DX storage class
    if (dataset.contains(tags::sop_class_uid)) {
        auto sop_class = dataset.get_string(tags::sop_class_uid);
        if (!sop_classes::is_dx_storage_sop_class(sop_class)) {
            findings.push_back({
                validation_severity::error,
                tags::sop_class_uid,
                "SOPClassUID is not a recognized DX Storage SOP Class: " + sop_class,
                "DX-ERR-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::dx_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_dx_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:

validate_voi_lut_module()

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

private

Definition at line 474 of file dx_iod_validator.cpp.

                                                   {
 
    // Window Center (0028,1050) and Window Width (0028,1051) - Type 1C for For Presentation
    if (options_.check_conditional) {
        bool has_window = dataset.contains(tags::window_center) &&
                         dataset.contains(tags::window_width);
 
        constexpr dicom_tag voi_lut_sequence{0x0028, 0x3010};
        bool has_voi_lut = dataset.contains(voi_lut_sequence);
 
        if (!has_window && !has_voi_lut) {
            findings.push_back({
                validation_severity::warning,
                tags::window_center,
                "For Presentation images should have Window Center/Width or VOI LUT Sequence "
                "for proper display",
                "DX-WARN-006"
            });
        }
    }
}

References kcenon::pacs::services::validation::dx_validation_options::check_conditional, kcenon::pacs::core::dicom_dataset::contains(), options_, kcenon::pacs::services::validation::warning, kcenon::pacs::core::tags::window_center, and kcenon::pacs::core::tags::window_width.

Referenced by validate_for_presentation().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

options_

dx_validation_options kcenon::pacs::services::validation::dx_iod_validator::options_

private

Definition at line 251 of file dx_iod_validator.h.

Referenced by options(), set_options(), validate(), validate_dx_anatomy_imaged_module(), validate_dx_detector_module(), validate_dx_image_module(), validate_dx_positioning_module(), validate_for_presentation(), validate_for_processing(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_patient_module(), validate_sop_common_module(), and validate_voi_lut_module().

---

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

• include/kcenon/pacs/services/validation/dx_iod_validator.h
• src/services/validation/dx_iod_validator.cpp