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

#include <mg_iod_validator.h>

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

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

	mg_iod_validator (const mg_validation_options &options)
	Construct validator with custom options.

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

validation_result	validate_for_presentation (const core::dicom_dataset &dataset) const
	Validate a For Presentation mammography dataset.

validation_result	validate_for_processing (const core::dicom_dataset &dataset) const
	Validate a For Processing mammography dataset.

validation_result	validate_laterality (const core::dicom_dataset &dataset) const
	Validate breast laterality attribute.

validation_result	validate_view_position (const core::dicom_dataset &dataset) const
	Validate mammography view position.

validation_result	validate_compression_force (const core::dicom_dataset &dataset) const
	Validate compression force.

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

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

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

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

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

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

void	check_compression_force_range (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
mg_validation_options	options_

Detailed Description

Validator for Digital Mammography X-Ray Image IODs.

Validates DICOM datasets against the Digital Mammography X-Ray Image IOD specification. This validator extends standard DX validation with mammography-specific requirements.

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 (with breast-specific requirements)
Mammography Image Module
DX Detector Module
SOP Common Module

Mammography-Specific Modules (M/C)

Mammography Series Module (M)
Mammography Image Module (M) - includes laterality, view position
X-Ray Acquisition Dose Module (C) - compression force, dose
Breast Implant Module (C) - if implants present

Conditional Modules (C)

DX Positioning Module
VOI LUT Module (For Presentation images)

Mammography-Specific Validations

Breast Laterality (0020,0060):
- Must be L, R, or B
- Should match Image Laterality (0020,0062) if present
View Position (0018,5101):
- Must be valid mammography view code (CC, MLO, ML, LM, etc.)
- View Code Sequence (0054,0220) preferred for coded values
Compression Force (0018,11A2):
- Validated against typical range (50-200 N)
- Warning if outside normal range

Example:: mg_iod_validator validator;

auto result = validator.validate(dataset);

if (!result.is_valid) {

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

if (finding.code.starts_with("MG-")) {

// Mammography-specific issue

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

}

}

}

kcenon::pacs::services::validation::mg_iod_validator
Validator for Digital Mammography X-Ray Image IODs.
Definition mg_iod_validator.h:162

kcenon::pacs::services::validation::mg_iod_validator::validate
validation_result validate(const core::dicom_dataset &dataset) const
Validate a DICOM dataset against Mammography IOD.
Definition mg_iod_validator.cpp:90

Definition at line 162 of file mg_iod_validator.h.

Constructor & Destructor Documentation

◆ mg_iod_validator() [1/2]

kcenon::pacs::services::validation::mg_iod_validator::mg_iod_validator ( )

default

Construct validator with default options.

◆ mg_iod_validator() [2/2]

kcenon::pacs::services::validation::mg_iod_validator::mg_iod_validator ( const mg_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options Validation options

Definition at line 87 of file mg_iod_validator.cpp.

88 : options_(options) {}

kcenon::pacs::services::validation::mg_iod_validator::options

const mg_validation_options & options() const noexcept

Get the validation options.

Definition mg_iod_validator.cpp:307

kcenon::pacs::services::validation::mg_iod_validator::options_

mg_validation_options options_

Definition mg_iod_validator.h:353

Member Function Documentation

◆ check_compression_force_range()

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

private

Definition at line 866 of file mg_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(mg_tags::compression_force)) {
        // Compression force is Type 3 but important for mammography QC
        findings.push_back({
            validation_severity::info,
            mg_tags::compression_force,
            "Compression Force (0018,11A2) is not present. "
            "This information is valuable for quality control and patient safety.",
            "MG-INFO-008"
        });
        return;
    }
 
    auto force = dataset.get_numeric<double>(mg_tags::compression_force);
    if (!force) {
        findings.push_back({
            validation_severity::warning,
            mg_tags::compression_force,
            "Compression Force is present but could not be parsed as a number.",
            "MG-WARN-012"
        });
        return;
    }
 
    auto [min_typical, max_typical] = get_typical_compression_force_range();
 
    if (!is_valid_compression_force(*force)) {
        findings.push_back({
            validation_severity::warning,
            mg_tags::compression_force,
            "Compression Force (" + std::to_string(*force) +
            " N) is outside the typical range (20-300 N). "
            "This may indicate a measurement error or non-standard technique.",
            "MG-WARN-013"
        });
    } else if (*force < min_typical || *force > max_typical) {
        findings.push_back({
            validation_severity::info,
            mg_tags::compression_force,
            "Compression Force (" + std::to_string(*force) +
            " N) is outside the typical screening range (" +
            std::to_string(min_typical) + "-" + std::to_string(max_typical) + " N).",
            "MG-INFO-009"
        });
    }
}

References kcenon::pacs::services::validation::mg_tags::compression_force, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::services::sop_classes::get_typical_compression_force_range(), kcenon::pacs::services::validation::info, kcenon::pacs::services::sop_classes::is_valid_compression_force(), and kcenon::pacs::services::validation::warning.

Referenced by validate_acquisition_dose_module(), and validate_compression_force().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_laterality_consistency()

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

private

Definition at line 734 of file mg_iod_validator.cpp.

                                                   {
 
    // Check Laterality (0020,0060) - Series level
    bool has_series_laterality = dataset.contains(mg_tags::laterality);
    // Check Image Laterality (0020,0062) - Image level
    bool has_image_laterality = dataset.contains(mg_tags::image_laterality);
 
    // At least one should be present for mammography
    if (!has_series_laterality && !has_image_laterality) {
        findings.push_back({
            validation_severity::error,
            mg_tags::laterality,
            "Neither Laterality (0020,0060) nor Image Laterality (0020,0062) is present. "
            "Breast laterality must be specified for mammography images.",
            "MG-ERR-003"
        });
        return;
    }
 
    // Validate Laterality value if present
    if (has_series_laterality) {
        auto lat = dataset.get_string(mg_tags::laterality);
        if (!is_valid_breast_laterality(lat)) {
            findings.push_back({
                validation_severity::error,
                mg_tags::laterality,
                "Invalid Laterality value: '" + lat +
                "'. Must be 'L' (left), 'R' (right), or 'B' (bilateral).",
                "MG-ERR-004"
            });
        }
    }
 
    // Validate Image Laterality value if present
    if (has_image_laterality) {
        auto img_lat = dataset.get_string(mg_tags::image_laterality);
        if (!is_valid_breast_laterality(img_lat)) {
            findings.push_back({
                validation_severity::error,
                mg_tags::image_laterality,
                "Invalid Image Laterality value: '" + img_lat +
                "'. Must be 'L' (left), 'R' (right), or 'B' (bilateral).",
                "MG-ERR-005"
            });
        }
    }
 
    // Check consistency between series and image laterality if both present
    if (has_series_laterality && has_image_laterality) {
        auto series_lat = dataset.get_string(mg_tags::laterality);
        auto image_lat = dataset.get_string(mg_tags::image_laterality);
 
        if (series_lat != image_lat) {
            findings.push_back({
                validation_severity::warning,
                mg_tags::image_laterality,
                "Laterality mismatch: Series Laterality is '" + series_lat +
                "' but Image Laterality is '" + image_lat + "'.",
                "MG-WARN-001"
            });
        }
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::mg_tags::image_laterality, kcenon::pacs::services::sop_classes::is_valid_breast_laterality(), kcenon::pacs::services::validation::mg_tags::laterality, and kcenon::pacs::services::validation::warning.

Referenced by validate_laterality(), and validate_mammography_image_module().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_modality()

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

private

Definition at line 715 of file mg_iod_validator.cpp.

                                                   {
 
    if (!dataset.contains(tags::modality)) {
        return;  // Already reported as Type 1 missing
    }
 
    auto modality = dataset.get_string(tags::modality);
    if (modality != "MG") {
        findings.push_back({
            validation_severity::error,
            tags::modality,
            "Modality must be 'MG' for mammography images, found: " + modality,
            "MG-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::mg_iod_validator::check_photometric_interpretation	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 975 of file mg_iod_validator.cpp.

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

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::error, kcenon::pacs::core::dicom_dataset::get_string(), 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::mg_iod_validator::check_pixel_data_consistency	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 916 of file mg_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) + ")",
                "MG-ERR-006"
            });
        }
 
        // Mammography typically uses 12-16 bits stored for high dynamic range
        if (*bits_stored < 12 || *bits_stored > 16) {
            findings.push_back({
                validation_severity::info,
                tags::bits_stored,
                "Mammography images typically use 12-16 bits, found: " +
                std::to_string(*bits_stored),
                "MG-INFO-010"
            });
        }
    }
 
    // 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) + ")",
                "MG-WARN-014"
            });
        }
    }
 
    // Mammography 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,
            "Mammography images must be grayscale (SamplesPerPixel = 1), found: " +
            std::to_string(*samples),
            "MG-ERR-007"
        });
    }
}

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::mg_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 668 of file mg_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() + ")",
            "MG-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() + ")",
                "MG-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_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_mammography_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::mg_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 697 of file mg_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() + ")",
            "MG-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:

◆ check_view_position_validity()

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

private

Definition at line 800 of file mg_iod_validator.cpp.

                                                   {
 
    // View Position (0018,5101) - Type 2 for mammography
    if (!dataset.contains(mg_tags::view_position)) {
        findings.push_back({
            validation_severity::warning,
            mg_tags::view_position,
            "View Position (0018,5101) is not present. "
            "This attribute should be specified for mammography images.",
            "MG-WARN-005"
        });
        return;
    }
 
    auto view_str = dataset.get_string(mg_tags::view_position);
    if (view_str.empty()) {
        findings.push_back({
            validation_severity::warning,
            mg_tags::view_position,
            "View Position is present but empty.",
            "MG-WARN-006"
        });
        return;
    }
 
    // Parse and validate view position
    auto view = parse_mg_view_position(view_str);
    if (view == mg_view_position::other) {
        // Check if it's a valid view we just don't recognize
        auto valid_views = get_valid_mg_view_positions();
        std::string valid_list;
        for (size_t i = 0; i < valid_views.size(); ++i) {
            if (i > 0) valid_list += ", ";
            valid_list += std::string(valid_views[i]);
        }
 
        findings.push_back({
            validation_severity::warning,
            mg_tags::view_position,
            "Unrecognized View Position: '" + view_str +
            "'. Common mammography views include: " + valid_list,
            "MG-WARN-010"
        });
    }
 
    // Additional validation: check laterality-view consistency
    if (dataset.contains(mg_tags::laterality) || dataset.contains(mg_tags::image_laterality)) {
        auto lat_str = dataset.contains(mg_tags::image_laterality)
            ? dataset.get_string(mg_tags::image_laterality)
            : dataset.get_string(mg_tags::laterality);
 
        auto laterality = parse_breast_laterality(lat_str);
 
        if (!is_valid_laterality_view_combination(laterality, view)) {
            findings.push_back({
                validation_severity::warning,
                mg_tags::view_position,
                "Unusual laterality-view combination: " + lat_str + " / " + view_str,
                "MG-WARN-011"
            });
        }
    }
}

References kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::get_valid_mg_view_positions(), kcenon::pacs::services::validation::mg_tags::image_laterality, kcenon::pacs::services::sop_classes::is_valid_laterality_view_combination(), kcenon::pacs::services::validation::mg_tags::laterality, kcenon::pacs::services::sop_classes::parse_breast_laterality(), kcenon::pacs::services::sop_classes::parse_mg_view_position(), kcenon::pacs::services::validation::mg_tags::view_position, and kcenon::pacs::services::validation::warning.

Referenced by validate_mammography_image_module(), and validate_view_position().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ options()

const mg_validation_options & kcenon::pacs::services::validation::mg_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Definition at line 307 of file mg_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::mg_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 and mammography-specific requirements.

Parameters

dataset The dataset to check

Returns: true if all critical attributes are present

Definition at line 269 of file mg_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 MG
    auto modality = dataset.get_string(tags::modality);
    if (modality != "MG") 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;
 
    // Mammography-specific: Laterality should be present
    if (!dataset.contains(mg_tags::laterality) &&
        !dataset.contains(mg_tags::image_laterality)) {
        return false;
    }
 
    return true;
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_options()

void kcenon::pacs::services::validation::mg_iod_validator::set_options ( const mg_validation_options & options )

Set validation options.

Definition at line 311 of file mg_iod_validator.cpp.

                                                                       {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

◆ validate()

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

nodiscard

Validate a DICOM dataset against Mammography IOD.

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

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 90 of file mg_iod_validator.cpp.

                                                                               {
    validation_result result;
    result.is_valid = true;
 
    // Validate standard 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);
    }
 
    // Validate mammography series module
    validate_mammography_series_module(dataset, result.findings);
 
    if (options_.validate_pixel_data) {
        validate_image_pixel_module(dataset, result.findings);
    }
 
    if (options_.validate_mg_specific) {
        validate_mammography_image_module(dataset, result.findings);
        validate_dx_anatomy_imaged_module(dataset, result.findings);
        validate_dx_detector_module(dataset, result.findings);
    }
 
    if (options_.validate_compression || options_.validate_dose_parameters) {
        validate_acquisition_dose_module(dataset, result.findings);
    }
 
    if (options_.validate_implant_attributes) {
        validate_breast_implant_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_for_presentation(), validate_for_processing(), and kcenon::pacs::services::validation::validate_mg_iod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_acquisition_dose_module()

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

private

Definition at line 507 of file mg_iod_validator.cpp.

                                                   {
 
    // Compression Force (0018,11A2) - Type 3 but important for mammography
    if (options_.validate_compression) {
        check_compression_force_range(dataset, findings);
    }
 
    // Body Part Thickness (0018,11A0) - Type 3
    if (options_.validate_dose_parameters) {
        if (dataset.contains(mg_tags::body_part_thickness)) {
            auto thickness = dataset.get_numeric<double>(mg_tags::body_part_thickness);
            if (thickness && !is_valid_compressed_breast_thickness(*thickness)) {
                findings.push_back({
                    validation_severity::warning,
                    mg_tags::body_part_thickness,
                    "Compressed breast thickness outside typical range (10-150mm): " +
                    std::to_string(*thickness) + " mm",
                    "MG-WARN-007"
                });
            }
        } else {
            // Recommend including thickness for quality assessment
            findings.push_back({
                validation_severity::info,
                mg_tags::body_part_thickness,
                "Compressed breast thickness not documented - "
                "recommended for dose assessment and quality control",
                "MG-INFO-005"
            });
        }
 
        // KVP (0018,0060) - Type 3 but important for dose
        if (!dataset.contains(mg_tags::kvp)) {
            findings.push_back({
                validation_severity::info,
                mg_tags::kvp,
                "KVP not documented - recommended for dose assessment",
                "MG-INFO-006"
            });
        }
 
        // Entrance Dose (0040,0302) - Type 3
        // Organ Dose (0040,0316) - Type 3 but important for breast dose tracking
    }
}

References kcenon::pacs::services::validation::mg_tags::body_part_thickness, check_compression_force_range(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_numeric(), kcenon::pacs::services::validation::info, kcenon::pacs::services::sop_classes::is_valid_compressed_breast_thickness(), kcenon::pacs::services::validation::mg_tags::kvp, options_, kcenon::pacs::services::validation::mg_validation_options::validate_compression, kcenon::pacs::services::validation::mg_validation_options::validate_dose_parameters, 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_breast_implant_module()

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

private

Definition at line 627 of file mg_iod_validator.cpp.

                                                   {
 
    // Breast Implant Present (0028,1300) - Type 3
    if (dataset.contains(mg_tags::breast_implant_present)) {
        auto implant = dataset.get_string(mg_tags::breast_implant_present);
        if (implant != "YES" && implant != "NO") {
            findings.push_back({
                validation_severity::warning,
                mg_tags::breast_implant_present,
                "Breast Implant Present should be 'YES' or 'NO', found: " + implant,
                "MG-WARN-009"
            });
        }
 
        // If implant is present, check for implant displaced views
        if (implant == "YES") {
            // Informational: implant displacement technique (Eklund) may be needed
            if (dataset.contains(mg_tags::view_position)) {
                auto view = dataset.get_string(mg_tags::view_position);
                auto parsed_view = parse_mg_view_position(view);
                if (parsed_view != mg_view_position::implant &&
                    parsed_view != mg_view_position::id) {
                    findings.push_back({
                        validation_severity::info,
                        mg_tags::view_position,
                        "Breast implant present but view is not implant-displaced (ID). "
                        "Implant displacement technique (Eklund) may improve visualization.",
                        "MG-INFO-007"
                    });
                }
            }
        }
    }
}

References kcenon::pacs::services::validation::mg_tags::breast_implant_present, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::sop_classes::implant, kcenon::pacs::services::validation::info, kcenon::pacs::services::sop_classes::parse_mg_view_position(), kcenon::pacs::services::validation::mg_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_compression_force()

validation_result kcenon::pacs::services::validation::mg_iod_validator::validate_compression_force ( const core::dicom_dataset & dataset ) const

nodiscard

Validate compression force.

Checks compression force is present and within typical range.

Parameters

dataset The dataset to validate

Returns: Validation result for compression force

Definition at line 253 of file mg_iod_validator.cpp.

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

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

Here is the call graph for this function:

◆ validate_dx_anatomy_imaged_module()

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

private

Definition at line 438 of file mg_iod_validator.cpp.

                                                   {
 
    // Body Part Examined (0018,0015) - Type 2
    if (options_.check_type2) {
        check_type2_attribute(dataset, mg_tags::body_part_examined, "BodyPartExamined", findings);
 
        if (dataset.contains(mg_tags::body_part_examined)) {
            auto body_part = dataset.get_string(mg_tags::body_part_examined);
            if (body_part != "BREAST") {
                findings.push_back({
                    validation_severity::warning,
                    mg_tags::body_part_examined,
                    "Body Part Examined should be 'BREAST' for mammography, found: " + body_part,
                    "MG-WARN-003"
                });
            }
        }
    }
 
    // Anatomic Region Sequence (0008,2218) - Type 1C
    if (options_.check_conditional) {
        if (!dataset.contains(mg_tags::body_part_examined) &&
            !dataset.contains(mg_tags::anatomic_region_sequence)) {
            findings.push_back({
                validation_severity::warning,
                mg_tags::anatomic_region_sequence,
                "Neither Body Part Examined nor Anatomic Region Sequence present - "
                "anatomy information may be insufficient for clinical use",
                "MG-WARN-004"
            });
        }
    }
}

References kcenon::pacs::services::validation::mg_tags::anatomic_region_sequence, kcenon::pacs::services::validation::mg_tags::body_part_examined, kcenon::pacs::services::validation::mg_validation_options::check_conditional, kcenon::pacs::services::validation::mg_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::core::dicom_dataset::get_string(), 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::mg_iod_validator::validate_dx_detector_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

Definition at line 474 of file mg_iod_validator.cpp.

                                                   {
 
    // Detector Type (0018,7004) - Type 2
    if (options_.check_type2) {
        check_type2_attribute(dataset, mg_tags::detector_type, "DetectorType", findings);
 
        if (dataset.contains(mg_tags::detector_type)) {
            auto type = dataset.get_string(mg_tags::detector_type);
            // Mammography typically uses DIRECT (a-Se) or SCINTILLATOR (CsI)
            if (type != "DIRECT" && type != "SCINTILLATOR" && type != "STORAGE") {
                findings.push_back({
                    validation_severity::info,
                    mg_tags::detector_type,
                    "Unusual Detector Type for mammography: " + type +
                    " (typical: DIRECT, SCINTILLATOR)",
                    "MG-INFO-004"
                });
            }
        }
    }
 
    // Imager Pixel Spacing (0018,1164) - Type 1 for DX/MG
    if (options_.check_type1) {
        check_type1_attribute(dataset, mg_tags::imager_pixel_spacing,
                              "ImagerPixelSpacing", findings);
 
        // Mammography typically has very fine pixel spacing (< 0.1 mm)
        // This is informational only
    }
}

References kcenon::pacs::services::validation::mg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::mg_validation_options::check_type2, check_type2_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::mg_tags::detector_type, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::services::validation::mg_tags::imager_pixel_spacing, kcenon::pacs::services::validation::info, and options_.

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::mg_iod_validator::validate_for_presentation ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a For Presentation mammography 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 139 of file mg_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(mg_tags::presentation_intent_type)) {
            auto intent = dataset.get_string(mg_tags::presentation_intent_type);
            if (intent != "FOR PRESENTATION") {
                result.findings.push_back({
                    validation_severity::error,
                    mg_tags::presentation_intent_type,
                    "Presentation Intent Type should be 'FOR PRESENTATION' "
                    "for this SOP Class, found: " + intent,
                    "MG-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::mg_tags::presentation_intent_type, validate(), kcenon::pacs::services::validation::mg_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::mg_iod_validator::validate_for_processing ( const core::dicom_dataset & dataset ) const

nodiscard

Validate a For Processing mammography 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 173 of file mg_iod_validator.cpp.

                                                                            {
    auto result = validate(dataset);
 
    // Additional For Processing validation
    if (options_.validate_processing_requirements) {
        // Check Presentation Intent Type
        if (dataset.contains(mg_tags::presentation_intent_type)) {
            auto intent = dataset.get_string(mg_tags::presentation_intent_type);
            if (intent != "FOR PROCESSING") {
                result.findings.push_back({
                    validation_severity::error,
                    mg_tags::presentation_intent_type,
                    "Presentation Intent Type should be 'FOR PROCESSING' "
                    "for this SOP Class, found: " + intent,
                    "MG-ERR-011"
                });
            }
        }
 
        // For Processing images should have linear pixel intensity relationship
        if (dataset.contains(mg_tags::pixel_intensity_relationship)) {
            auto relationship = dataset.get_string(mg_tags::pixel_intensity_relationship);
            if (relationship != "LIN") {
                result.findings.push_back({
                    validation_severity::info,
                    mg_tags::pixel_intensity_relationship,
                    "For Processing mammography images typically have linear (LIN) "
                    "pixel intensity relationship, found: " + relationship,
                    "MG-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::mg_tags::pixel_intensity_relationship, kcenon::pacs::services::validation::mg_tags::presentation_intent_type, validate(), and kcenon::pacs::services::validation::mg_validation_options::validate_processing_requirements.

Here is the call graph for this function:

◆ validate_general_series_module()

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

private

Definition at line 351 of file mg_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 "MG"
        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::mg_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::mg_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::mg_iod_validator::validate_general_study_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

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

private

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

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_laterality()

validation_result kcenon::pacs::services::validation::mg_iod_validator::validate_laterality ( const core::dicom_dataset & dataset ) const

nodiscard

Validate breast laterality attribute.

Checks that laterality is present, valid, and consistent with related attributes.

Parameters

dataset The dataset to validate

Returns: Validation result for laterality

Definition at line 219 of file mg_iod_validator.cpp.

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

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

Here is the call graph for this function:

◆ validate_mammography_image_module()

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

private

Definition at line 390 of file mg_iod_validator.cpp.

                                                   {
 
    // Image Type (0008,0008) - Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, mg_tags::image_type, "ImageType", findings);
 
        if (dataset.contains(mg_tags::image_type)) {
            auto image_type = dataset.get_string(mg_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,
                    mg_tags::image_type,
                    "Image Type first value should be ORIGINAL or DERIVED",
                    "MG-WARN-002"
                });
            }
        }
    }
 
    // Validate laterality if enabled
    if (options_.validate_laterality) {
        check_laterality_consistency(dataset, findings);
    }
 
    // Validate view position if enabled
    if (options_.validate_view_position) {
        check_view_position_validity(dataset, findings);
    }
 
    // Partial View (0028,1350) - Type 3
    if (dataset.contains(mg_tags::partial_view)) {
        auto partial = dataset.get_string(mg_tags::partial_view);
        if (partial == "YES" && !dataset.contains(mg_tags::partial_view_description) &&
            !dataset.contains(mg_tags::partial_view_code_sequence)) {
            findings.push_back({
                validation_severity::info,
                mg_tags::partial_view_description,
                "Partial View is YES but no description or code sequence provided",
                "MG-INFO-003"
            });
        }
    }
}

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_mammography_series_module()

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

private

Definition at line 370 of file mg_iod_validator.cpp.

                                                   {
 
    // Mammography Series Module includes Request Attributes Sequence (0040,0275)
    // which is Type 3, so no validation required but informational
 
    if (options_.check_conditional) {
        // The Request Attributes Sequence is useful for workflow integration
        if (!dataset.contains(mg_tags::request_attributes_sequence)) {
            findings.push_back({
                validation_severity::info,
                mg_tags::request_attributes_sequence,
                "Request Attributes Sequence not present - may limit workflow integration",
                "MG-INFO-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::mg_validation_options::check_conditional, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::info, options_, and kcenon::pacs::services::validation::mg_tags::request_attributes_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::mg_iod_validator::validate_patient_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

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

private

Definition at line 603 of file mg_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 mammography storage class
    if (dataset.contains(tags::sop_class_uid)) {
        auto sop_class = dataset.get_string(tags::sop_class_uid);
        if (!is_mg_storage_sop_class(sop_class)) {
            findings.push_back({
                validation_severity::error,
                tags::sop_class_uid,
                "SOPClassUID is not a recognized Mammography Storage SOP Class: " + sop_class,
                "MG-ERR-001"
            });
        }
    }
}

References kcenon::pacs::services::validation::mg_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_mg_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_view_position()

validation_result kcenon::pacs::services::validation::mg_iod_validator::validate_view_position ( const core::dicom_dataset & dataset ) const

nodiscard

Validate mammography view position.

Checks that view position is present and contains a valid mammography view code.

Parameters

dataset The dataset to validate

Returns: Validation result for view position

Definition at line 236 of file mg_iod_validator.cpp.

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

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

Here is the call graph for this function:

◆ validate_voi_lut_module()

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

private

Definition at line 579 of file mg_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 mammography images should have Window Center/Width "
                "or VOI LUT Sequence for proper display",
                "MG-WARN-008"
            });
        }
    }
}

References kcenon::pacs::services::validation::mg_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_

mg_validation_options kcenon::pacs::services::validation::mg_iod_validator::options_

private

Definition at line 353 of file mg_iod_validator.h.

Referenced by options(), set_options(), validate(), validate_acquisition_dose_module(), validate_dx_anatomy_imaged_module(), validate_dx_detector_module(), validate_for_presentation(), validate_for_processing(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_mammography_image_module(), validate_mammography_series_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/mg_iod_validator.h
src/services/validation/mg_iod_validator.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Validated Modules

Mandatory Modules (M)

Mammography-Specific Modules (M/C)

Conditional Modules (C)

Mammography-Specific Validations

Constructor & Destructor Documentation

◆ mg_iod_validator() [1/2]

◆ mg_iod_validator() [2/2]

Member Function Documentation

◆ check_compression_force_range()

◆ check_laterality_consistency()

◆ check_modality()

◆ check_photometric_interpretation()

◆ check_pixel_data_consistency()

◆ check_type1_attribute()

◆ check_type2_attribute()

◆ check_view_position_validity()

◆ options()

◆ quick_check()

◆ set_options()

◆ validate()

◆ validate_acquisition_dose_module()

◆ validate_breast_implant_module()

◆ validate_compression_force()

◆ validate_dx_anatomy_imaged_module()

◆ validate_dx_detector_module()

◆ validate_for_presentation()

◆ validate_for_processing()

◆ validate_general_series_module()

◆ validate_general_study_module()

◆ validate_image_pixel_module()

◆ validate_laterality()

◆ validate_mammography_image_module()

◆ validate_mammography_series_module()

◆ validate_patient_module()

◆ validate_sop_common_module()

◆ validate_view_position()

◆ validate_voi_lut_module()

Member Data Documentation

◆ options_