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

#include <xa_iod_validator.h>

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

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

	xa_iod_validator (const xa_validation_options &options)
	Construct validator with custom options.

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

validation_result	validate_multiframe (const core::dicom_dataset &dataset) const
	Validate a multi-frame XA dataset.

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

validation_result	validate_calibration (const core::dicom_dataset &dataset) const
	Validate calibration data for quantitative analysis.

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

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

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

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

Private Attributes
xa_validation_options	options_

Detailed Description

Validator for X-Ray Angiographic Image IODs.

Validates DICOM datasets against the XA Image IOD and Enhanced XA Image IOD specifications. Checks required modules, attributes, and value constraints specific to angiographic imaging.

Validated Modules

Mandatory Modules

Patient Module (M)
General Study Module (M)
General Series Module (M)
General Equipment Module (M)
General Image Module (M)
Image Pixel Module (M)
XA/XRF Acquisition Module (M)
XA/XRF Image Module (M)
SOP Common Module (M)

Conditional Modules

Multi-frame Module (C) - for multi-frame XA
Cine Module (C) - for multi-frame XA
XA Calibration Module (C) - for quantitative analysis

Example:: xa_iod_validator validator;

auto result = validator.validate(dataset);

if (!result.is_valid) {

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

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

}

}

kcenon::pacs::services::validation::xa_iod_validator
Validator for X-Ray Angiographic Image IODs.
Definition xa_iod_validator.h:181

kcenon::pacs::services::validation::xa_iod_validator::validate
validation_result validate(const core::dicom_dataset &dataset) const
Validate a DICOM dataset against XA IOD.
Definition xa_iod_validator.cpp:27

Definition at line 181 of file xa_iod_validator.h.

Constructor & Destructor Documentation

◆ xa_iod_validator() [1/2]

kcenon::pacs::services::validation::xa_iod_validator::xa_iod_validator ( )

default

Construct validator with default options.

◆ xa_iod_validator() [2/2]

kcenon::pacs::services::validation::xa_iod_validator::xa_iod_validator ( const xa_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options Validation options

Definition at line 24 of file xa_iod_validator.cpp.

25 : options_(options) {}

kcenon::pacs::services::validation::xa_iod_validator::options

const xa_validation_options & options() const noexcept

Get the validation options.

Definition xa_iod_validator.cpp:139

kcenon::pacs::services::validation::xa_iod_validator::options_

xa_validation_options options_

Definition xa_iod_validator.h:313

Member Function Documentation

◆ check_modality()

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

private

Definition at line 432 of file xa_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::modality)) {
        return;  // Already reported as Type 1 missing
    }
 
    auto modality = dataset.get_string(tags::modality);
    if (modality != "XA" && modality != "XRF") {
        findings.push_back({
            validation_severity::error,
            tags::modality,
            "Modality must be 'XA' or 'XRF' for angiographic images, found: " + modality,
            "XA-ERR-003"
        });
    }
}

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

private

Definition at line 471 of file xa_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) + ")",
                "XA-ERR-005"
            });
        }
 
        // XA typically uses 8, 10, 12, or 16 bits
        if (*bits_stored != 8 && *bits_stored != 10 &&
            *bits_stored != 12 && *bits_stored != 16) {
            findings.push_back({
                validation_severity::warning,
                tags::bits_stored,
                "Unusual BitsStored for XA: " + std::to_string(*bits_stored) +
                " (expected 8, 10, 12, or 16)",
                "XA-WARN-004"
            });
        }
    }
 
    // 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) + ")",
                "XA-WARN-005"
            });
        }
    }
 
    // XA must be grayscale (SamplesPerPixel = 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,
            "XA images must be grayscale (SamplesPerPixel = 1), found: " +
            std::to_string(*samples),
            "XA-ERR-006"
        });
    }
 
    // XA uses unsigned integers (PixelRepresentation = 0)
    auto pixel_rep = dataset.get_numeric<uint16_t>(tags::pixel_representation);
    if (pixel_rep && *pixel_rep != 0) {
        findings.push_back({
            validation_severity::warning,
            tags::pixel_representation,
            "XA images typically use unsigned integers (PixelRepresentation = 0)",
            "XA-WARN-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::core::tags::pixel_representation, 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_positioner_angles()

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

private

Definition at line 542 of file xa_iod_validator.cpp.

                                                   {
 
    bool has_primary = dataset.contains(xa_tags::positioner_primary_angle);
    bool has_secondary = dataset.contains(xa_tags::positioner_secondary_angle);
 
    // Both angles should be present for proper geometry reconstruction
    if (has_primary != has_secondary) {
        findings.push_back({
            validation_severity::warning,
            has_primary ? xa_tags::positioner_secondary_angle
                        : xa_tags::positioner_primary_angle,
            "Only one positioner angle present - complete geometry unavailable",
            "XA-WARN-007"
        });
    }
 
    if (!has_primary && !has_secondary) {
        findings.push_back({
            validation_severity::info,
            xa_tags::positioner_primary_angle,
            "No positioner angle information - geometry reconstruction not possible",
            "XA-INFO-004"
        });
    }
 
    // Validate angle ranges if present
    if (has_primary) {
        auto angle = dataset.get_numeric<double>(xa_tags::positioner_primary_angle);
        if (angle && (*angle < -180.0 || *angle > 180.0)) {
            findings.push_back({
                validation_severity::warning,
                xa_tags::positioner_primary_angle,
                "PositionerPrimaryAngle (" + std::to_string(*angle) +
                ") outside typical range [-180, 180]",
                "XA-WARN-008"
            });
        }
    }
 
    if (has_secondary) {
        auto angle = dataset.get_numeric<double>(xa_tags::positioner_secondary_angle);
        if (angle && (*angle < -90.0 || *angle > 90.0)) {
            findings.push_back({
                validation_severity::warning,
                xa_tags::positioner_secondary_angle,
                "PositionerSecondaryAngle (" + std::to_string(*angle) +
                ") outside typical range [-90, 90]",
                "XA-WARN-009"
            });
        }
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::services::validation::info, kcenon::pacs::services::validation::xa_tags::positioner_primary_angle, kcenon::pacs::services::validation::xa_tags::positioner_secondary_angle, 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:

◆ check_type1_attribute()

void kcenon::pacs::services::validation::xa_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 385 of file xa_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() + ")",
            "XA-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() + ")",
                "XA-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_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_multiframe_module(), validate_sop_common_module(), and validate_xa_image_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::xa_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 414 of file xa_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() + ")",
            "XA-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_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:

◆ check_xa_photometric()

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

private

Definition at line 451 of file xa_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::photometric_interpretation)) {
        return;  // Will be reported by pixel module validation
    }
 
    auto photometric = dataset.get_string(tags::photometric_interpretation);
    if (!sop_classes::is_valid_xa_photometric(photometric)) {
        findings.push_back({
            validation_severity::error,
            tags::photometric_interpretation,
            "Invalid photometric interpretation for XA: " + photometric +
            " (must be MONOCHROME1 or MONOCHROME2)",
            "XA-ERR-004"
        });
    }
}

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

Referenced by validate_xa_image_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ options()

const xa_validation_options & kcenon::pacs::services::validation::xa_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Definition at line 139 of file xa_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::xa_iod_validator::quick_check ( const core::dicom_dataset & dataset ) const

nodiscard

Quick check if dataset has minimum required XA 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 87 of file xa_iod_validator.cpp.

                                                                     {
    // Check only Type 1 required 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 XA or XRF
    auto modality = dataset.get_string(tags::modality);
    if (modality != "XA" && modality != "XRF") 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;
 
    // XA Image Module Type 1
    if (!dataset.contains(tags::image_type)) 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;
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_options()

void kcenon::pacs::services::validation::xa_iod_validator::set_options ( const xa_validation_options & options )

Set validation options.

Definition at line 143 of file xa_iod_validator.cpp.

                                                                       {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

◆ validate()

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

nodiscard

Validate a DICOM dataset against XA IOD.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 27 of file xa_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_xa_acquisition_module(dataset, result.findings);
        validate_xa_image_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_positioner) {
        check_positioner_angles(dataset, result.findings);
    }
 
    if (options_.validate_calibration) {
        validate_calibration_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 validate_multiframe(), and kcenon::pacs::services::validation::validate_xa_iod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_calibration()

validation_result kcenon::pacs::services::validation::xa_iod_validator::validate_calibration ( const core::dicom_dataset & dataset ) const

nodiscard

Validate calibration data for quantitative analysis.

Specifically checks if the dataset has valid calibration information suitable for QCA (Quantitative Coronary Analysis) measurements.

Parameters

dataset The dataset to check

Returns: Validation result focused on calibration attributes

Definition at line 123 of file xa_iod_validator.cpp.

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

Here is the call graph for this function:

◆ validate_calibration_module()

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

private

Definition at line 306 of file xa_iod_validator.cpp.

                                                   {
 
    // XA Calibration Module (Conditional)
    // Required if quantitative measurements are to be performed
 
    bool has_imager_spacing = dataset.contains(xa_tags::imager_pixel_spacing);
    bool has_sid = dataset.contains(xa_tags::distance_source_to_detector);
    bool has_sod = dataset.contains(xa_tags::distance_source_to_patient);
 
    // Imager Pixel Spacing is essential for any calibration
    if (!has_imager_spacing) {
        findings.push_back({
            validation_severity::warning,
            xa_tags::imager_pixel_spacing,
            "ImagerPixelSpacing (0018,1164) not present - "
            "quantitative measurements not possible",
            "XA-WARN-002"
        });
    }
 
    // SID and SOD needed for accurate isocenter calibration
    if (has_imager_spacing && (!has_sid || !has_sod)) {
        findings.push_back({
            validation_severity::warning,
            xa_tags::distance_source_to_detector,
            "DistanceSourceToDetector or DistanceSourceToPatient missing - "
            "magnification correction not possible for QCA",
            "XA-WARN-003"
        });
    }
 
    // Validate SID > SOD (physical constraint)
    if (has_sid && has_sod) {
        auto sid = dataset.get_numeric<double>(xa_tags::distance_source_to_detector);
        auto sod = dataset.get_numeric<double>(xa_tags::distance_source_to_patient);
 
        if (sid && sod && *sid <= *sod) {
            findings.push_back({
                validation_severity::error,
                xa_tags::distance_source_to_detector,
                "DistanceSourceToDetector (" + std::to_string(*sid) +
                ") must be greater than DistanceSourceToPatient (" +
                std::to_string(*sod) + ")",
                "XA-ERR-001"
            });
        }
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::xa_tags::distance_source_to_detector, kcenon::pacs::services::validation::xa_tags::distance_source_to_patient, kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::services::validation::xa_tags::imager_pixel_spacing, and kcenon::pacs::services::validation::warning.

Referenced by validate(), and validate_calibration().

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

private

Definition at line 183 of file xa_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 "XA" or "XRF"
        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::xa_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::xa_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::xa_iod_validator::validate_general_study_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 164 of file xa_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::xa_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::xa_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::xa_iod_validator::validate_image_pixel_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 245 of file xa_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);
    }
}

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_multiframe()

validation_result kcenon::pacs::services::validation::xa_iod_validator::validate_multiframe ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a multi-frame XA dataset.

Performs additional validation for multi-frame specific attributes including frame timing and per-frame calibration.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 69 of file xa_iod_validator.cpp.

                                                                        {
    // First do standard validation
    auto result = validate(dataset);
 
    // Then add multi-frame specific validation
    validate_multiframe_module(dataset, result.findings);
 
    // Re-check validity after multi-frame validation
    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, validate(), and validate_multiframe_module().

Here is the call graph for this function:

◆ validate_multiframe_module()

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

private

Definition at line 268 of file xa_iod_validator.cpp.

                                                   {
 
    // NumberOfFrames is Type 1 for multi-frame
    if (options_.check_type1) {
        check_type1_attribute(dataset, xa_tags::number_of_frames, "NumberOfFrames", findings);
    }
 
    // Frame timing validation
    if (options_.validate_multiframe_timing && options_.check_conditional) {
        bool has_frame_time = dataset.contains(xa_tags::frame_time);
        bool has_frame_time_vector = dataset.contains(xa_tags::frame_time_vector);
 
        if (!has_frame_time && !has_frame_time_vector) {
            findings.push_back({
                validation_severity::warning,
                xa_tags::frame_time,
                "Neither FrameTime (0018,1063) nor FrameTimeVector (0018,1065) present - "
                "frame timing information missing for cine playback",
                "XA-WARN-001"
            });
        }
 
        // CineRate is useful for proper playback
        if (!dataset.contains(xa_tags::cine_rate) &&
            !dataset.contains(xa_tags::recommended_display_frame_rate)) {
            findings.push_back({
                validation_severity::info,
                xa_tags::cine_rate,
                "Neither CineRate nor RecommendedDisplayFrameRate present - "
                "display timing may be incorrect",
                "XA-INFO-003"
            });
        }
    }
}

Referenced by validate_multiframe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_patient_module()

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

private

Definition at line 151 of file xa_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::xa_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::xa_iod_validator::validate_sop_common_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 357 of file xa_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 an XA/XRF storage class
    if (dataset.contains(tags::sop_class_uid)) {
        auto sop_class = dataset.get_string(tags::sop_class_uid);
        if (!sop_classes::is_xa_storage_sop_class(sop_class)) {
            findings.push_back({
                validation_severity::error,
                tags::sop_class_uid,
                "SOPClassUID is not a recognized XA/XRF Storage SOP Class: " + sop_class,
                "XA-ERR-002"
            });
        }
    }
}

References kcenon::pacs::services::validation::xa_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_xa_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_xa_acquisition_module()

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

private

Definition at line 202 of file xa_iod_validator.cpp.

                                                   {
 
    // XA/XRF Acquisition Module
    // Most attributes are Type 3 (optional), but we can provide info findings
 
    if (options_.check_conditional) {
        // Field of View info - Type 3 but useful for QA
        if (!dataset.contains(xa_tags::field_of_view_shape)) {
            findings.push_back({
                validation_severity::info,
                xa_tags::field_of_view_shape,
                "FieldOfViewShape (0018,1147) not present - FOV information unavailable",
                "XA-INFO-001"
            });
        }
 
        // Positioner motion for rotational acquisitions
        if (!dataset.contains(xa_tags::positioner_motion)) {
            findings.push_back({
                validation_severity::info,
                xa_tags::positioner_motion,
                "PositionerMotion (0018,1500) not present - motion type unknown",
                "XA-INFO-002"
            });
        }
    }
}

References kcenon::pacs::services::validation::xa_validation_options::check_conditional, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::xa_tags::field_of_view_shape, kcenon::pacs::services::validation::info, options_, and kcenon::pacs::services::validation::xa_tags::positioner_motion.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_xa_image_module()

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

private

Definition at line 232 of file xa_iod_validator.cpp.

                                                   {
 
    // Type 1 - Image Type
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::image_type, "ImageType", findings);
    }
 
    // Check photometric interpretation is valid for XA
    check_xa_photometric(dataset, findings);
}

References kcenon::pacs::services::validation::xa_validation_options::check_type1, check_type1_attribute(), check_xa_photometric(), kcenon::pacs::core::tags::image_type, and options_.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ options_

xa_validation_options kcenon::pacs::services::validation::xa_iod_validator::options_

private

Definition at line 313 of file xa_iod_validator.h.

Referenced by options(), set_options(), validate(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_multiframe_module(), validate_patient_module(), validate_sop_common_module(), validate_xa_acquisition_module(), and validate_xa_image_module().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Validated Modules

Mandatory Modules

Conditional Modules

Constructor & Destructor Documentation

◆ xa_iod_validator() [1/2]

◆ xa_iod_validator() [2/2]

Member Function Documentation

◆ check_modality()

◆ check_pixel_data_consistency()

◆ check_positioner_angles()

◆ check_type1_attribute()

◆ check_type2_attribute()

◆ check_xa_photometric()

◆ options()

◆ quick_check()

◆ set_options()

◆ validate()

◆ validate_calibration()

◆ validate_calibration_module()

◆ validate_general_series_module()

◆ validate_general_study_module()

◆ validate_image_pixel_module()

◆ validate_multiframe()

◆ validate_multiframe_module()

◆ validate_patient_module()

◆ validate_sop_common_module()

◆ validate_xa_acquisition_module()

◆ validate_xa_image_module()

Member Data Documentation

◆ options_