Validator for VL Whole Slide Microscopy Image IODs. More...

#include <wsi_iod_validator.h>

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

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

	wsi_iod_validator (const wsi_validation_options &options)
	Construct validator with custom options.

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

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

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

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

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

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

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

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

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

void	check_type1_attribute (const core::dicom_dataset &dataset, core::dicom_tag tag, std::string_view name, std::vector< validation_finding > &findings) const

void	check_type2_attribute (const core::dicom_dataset &dataset, core::dicom_tag tag, std::string_view name, std::vector< validation_finding > &findings) const

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

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

Private Attributes
wsi_validation_options	options_

Detailed Description

Validator for VL Whole Slide Microscopy Image IODs.

Validates DICOM datasets against the VL Whole Slide Microscopy Image IOD specification (PS3.3 Section A.32.8).

Validated Modules (PS3.3 Table A.32.8-1)

Mandatory Modules

Patient Module (M)
General Study Module (M)
General Series Module (M) — Modality = "SM"
Whole Slide Microscopy Image Module (M)
Optical Path Module (M)
Multi-frame Dimension Module (M)
Image Pixel Module (M)
SOP Common Module (M)

User Optional Modules

Specimen Module (U) — checked at info level

Example:: wsi_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::wsi_iod_validator
Validator for VL Whole Slide Microscopy Image IODs.
Definition wsi_iod_validator.h:146

kcenon::pacs::services::validation::wsi_iod_validator::validate
validation_result validate(const core::dicom_dataset &dataset) const
Validate a DICOM dataset against WSI IOD.
Definition wsi_iod_validator.cpp:28

Definition at line 146 of file wsi_iod_validator.h.

Constructor & Destructor Documentation

◆ wsi_iod_validator() [1/2]

kcenon::pacs::services::validation::wsi_iod_validator::wsi_iod_validator ( )

default

Construct validator with default options.

◆ wsi_iod_validator() [2/2]

kcenon::pacs::services::validation::wsi_iod_validator::wsi_iod_validator ( const wsi_validation_options & options )

explicit

Construct validator with custom options.

Parameters

options Validation options

Definition at line 25 of file wsi_iod_validator.cpp.

26 : options_(options) {}

kcenon::pacs::services::validation::wsi_iod_validator::options_

wsi_validation_options options_

Definition wsi_iod_validator.h:244

kcenon::pacs::services::validation::wsi_iod_validator::options

const wsi_validation_options & options() const noexcept

Get the validation options.

Definition wsi_iod_validator.cpp:110

Member Function Documentation

◆ check_modality()

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

private

Definition at line 403 of file wsi_iod_validator.cpp.

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

private

Definition at line 420 of file wsi_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) + ")",
                 "WSI-ERR-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) + ")",
                 "WSI-WARN-002"});
        }
    }
 
    // Validate PhotometricInterpretation for WSI
    if (dataset.contains(tags::photometric_interpretation)) {
        auto photometric =
            dataset.get_string(tags::photometric_interpretation);
        if (!sop_classes::is_valid_wsi_photometric(photometric)) {
            findings.push_back(
                {validation_severity::error,
                 tags::photometric_interpretation,
                 "WSI images must use RGB, YBR_FULL_422, YBR_ICT, YBR_RCT, "
                 "or MONOCHROME2, found: " + photometric,
                 "WSI-ERR-005"});
        }
    }
 
    // WSI SamplesPerPixel must be 1 (grayscale/fluorescence) or 3 (color)
    auto samples = dataset.get_numeric<uint16_t>(tags::samples_per_pixel);
    if (samples && *samples != 1 && *samples != 3) {
        findings.push_back(
            {validation_severity::error, tags::samples_per_pixel,
             "WSI images require SamplesPerPixel of 1 or 3, found: " +
                 std::to_string(*samples),
             "WSI-ERR-006"});
    }
 
    // WSI images must use unsigned pixel representation
    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,
             "WSI images typically use unsigned pixel representation "
             "(PixelRepresentation = 0)",
             "WSI-WARN-003"});
    }
}

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::wsi_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 366 of file wsi_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() + ")",
             "WSI-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() + ")",
                 "WSI-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_dimension_module(), validate_optical_path_module(), validate_sop_common_module(), and validate_wsi_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::wsi_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 389 of file wsi_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() + ")",
             "WSI-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:

◆ options()

const wsi_validation_options & kcenon::pacs::services::validation::wsi_iod_validator::options ( ) const

nodiscardnoexcept

Get the validation options.

Definition at line 110 of file wsi_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::wsi_iod_validator::quick_check ( const core::dicom_dataset & dataset ) const

nodiscard

Quick check if dataset has minimum required WSI attributes.

Parameters

dataset The dataset to check

Returns: true if all Type 1 attributes are present

Definition at line 75 of file wsi_iod_validator.cpp.

                                                                      {
    // 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 SM
    auto modality = dataset.get_string(tags::modality);
    if (modality != "SM") return false;
 
    // WSI Image Module Type 1
    if (!dataset.contains(tags::image_type)) return false;
    if (!dataset.contains(wsi_iod_tags::total_pixel_matrix_columns))
        return false;
    if (!dataset.contains(wsi_iod_tags::total_pixel_matrix_rows)) 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;
 
    // 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_wsi_dataset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_options()

void kcenon::pacs::services::validation::wsi_iod_validator::set_options ( const wsi_validation_options & options )

Set validation options.

Definition at line 114 of file wsi_iod_validator.cpp.

                                                                         {
    options_ = options;
}

References options(), and options_.

Here is the call graph for this function:

◆ validate()

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

nodiscard

Validate a DICOM dataset against WSI IOD.

Parameters

dataset The dataset to validate

Returns: Validation result with all findings

Definition at line 28 of file wsi_iod_validator.cpp.

                                        {
    validation_result result;
    result.is_valid = true;
 
    // Validate mandatory modules (PS3.3 Table A.32.8-1)
    if (options_.check_type1 || options_.check_type2) {
        validate_patient_module(dataset, result.findings);
        validate_general_study_module(dataset, result.findings);
        validate_general_series_module(dataset, result.findings);
        validate_sop_common_module(dataset, result.findings);
    }
 
    if (options_.validate_wsi_params) {
        validate_wsi_image_module(dataset, result.findings);
        validate_multiframe_dimension_module(dataset, result.findings);
    }
 
    if (options_.validate_optical_path) {
        validate_optical_path_module(dataset, result.findings);
    }
 
    if (options_.validate_pixel_data) {
        validate_image_pixel_module(dataset, result.findings);
    }
 
    // Specimen Module is User Optional — info-level checks
    if (options_.check_conditional) {
        validate_specimen_module(dataset, result.findings);
    }
 
    // Determine overall validity
    for (const auto& finding : result.findings) {
        if (finding.severity == validation_severity::error) {
            result.is_valid = false;
            break;
        }
        if (options_.strict_mode &&
            finding.severity == validation_severity::warning) {
            result.is_valid = false;
            break;
        }
    }
 
    return result;
}

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

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

private

Definition at line 163 of file wsi_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);
 
        // Modality must be "SM"
        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::wsi_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::services::validation::wsi_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::wsi_iod_validator::validate_general_study_module	(	const core::dicom_dataset &	dataset,
		std::vector< validation_finding > &	findings ) const

private

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

private

Definition at line 286 of file wsi_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);
    }
 
    // Validate pixel data consistency
    if (options_.validate_pixel_data) {
        check_pixel_data_consistency(dataset, findings);
    }
}

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

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_multiframe_dimension_module()

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

private

Definition at line 263 of file wsi_iod_validator.cpp.

                                                   {
 
    // Dimension Organization Type is Type 1
    check_type1_attribute(dataset, wsi_iod_tags::dimension_organization_type,
                          "DimensionOrganizationType", findings);
 
    // Validate the Dimension Organization Type value
    if (dataset.contains(wsi_iod_tags::dimension_organization_type)) {
        auto org_type =
            dataset.get_string(wsi_iod_tags::dimension_organization_type);
        if (org_type != "TILED_FULL" && org_type != "TILED_SPARSE") {
            findings.push_back(
                {validation_severity::error,
                 wsi_iod_tags::dimension_organization_type,
                 "DimensionOrganizationType must be 'TILED_FULL' or "
                 "'TILED_SPARSE' for WSI, found: " + org_type,
                 "WSI-ERR-001"});
        }
    }
}

References check_type1_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::wsi_iod_tags::dimension_organization_type, kcenon::pacs::services::validation::error, and kcenon::pacs::core::dicom_dataset::get_string().

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_optical_path_module()

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

private

Definition at line 240 of file wsi_iod_validator.cpp.

                                                   {
 
    // Optical Path Module — Optical Path Identifier is Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, wsi_iod_tags::optical_path_identifier,
                              "OpticalPathIdentifier", findings);
    }
 
    // Optical Path Description is Type 3 (optional), info if missing
    if (options_.check_conditional) {
        if (!dataset.contains(wsi_iod_tags::optical_path_description)) {
            findings.push_back(
                {validation_severity::info,
                 wsi_iod_tags::optical_path_description,
                 "OpticalPathDescription (0048,0106) not present - optical "
                 "path details unavailable",
                 "WSI-INFO-003"});
        }
    }
}

References kcenon::pacs::services::validation::wsi_validation_options::check_conditional, kcenon::pacs::services::validation::wsi_validation_options::check_type1, check_type1_attribute(), kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::info, kcenon::pacs::services::validation::wsi_iod_tags::optical_path_description, kcenon::pacs::services::validation::wsi_iod_tags::optical_path_identifier, and options_.

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

private

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

private

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

References kcenon::pacs::services::validation::wsi_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_wsi_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_specimen_module()

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

private

Definition at line 313 of file wsi_iod_validator.cpp.

                                                   {
 
    // Specimen Module is User Optional (U) for WSI
    // Provide info-level findings when specimen data is absent
 
    if (!dataset.contains(wsi_iod_tags::specimen_identifier)) {
        findings.push_back(
            {validation_severity::info, wsi_iod_tags::specimen_identifier,
             "SpecimenIdentifier (0040,0551) not present - specimen "
             "tracking unavailable",
             "WSI-INFO-004"});
    }
 
    if (!dataset.contains(wsi_iod_tags::container_identifier)) {
        findings.push_back(
            {validation_severity::info, wsi_iod_tags::container_identifier,
             "ContainerIdentifier (0040,0512) not present - container "
             "tracking unavailable",
             "WSI-INFO-005"});
    }
}

References kcenon::pacs::services::validation::wsi_iod_tags::container_identifier, kcenon::pacs::core::dicom_dataset::contains(), kcenon::pacs::services::validation::info, and kcenon::pacs::services::validation::wsi_iod_tags::specimen_identifier.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_wsi_image_module()

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

private

Definition at line 184 of file wsi_iod_validator.cpp.

                                                   {
 
    // WSI Image Module (PS3.3 Section C.8.12.4)
 
    // ImageType is Type 1
    if (options_.check_type1) {
        check_type1_attribute(dataset, tags::image_type, "ImageType",
                              findings);
    }
 
    // Total Pixel Matrix Columns/Rows are Type 1
    check_type1_attribute(dataset, wsi_iod_tags::total_pixel_matrix_columns,
                          "TotalPixelMatrixColumns", findings);
    check_type1_attribute(dataset, wsi_iod_tags::total_pixel_matrix_rows,
                          "TotalPixelMatrixRows", findings);
 
    // Number of Frames is Type 1 for multi-frame WSI
    if (options_.check_type1) {
        check_type1_attribute(dataset, wsi_iod_tags::number_of_frames,
                              "NumberOfFrames", findings);
    }
 
    // Informational checks for WSI-specific attributes
    if (options_.check_conditional) {
        // Imaged Volume Width/Height — important for physical measurements
        if (!dataset.contains(wsi_iod_tags::imaged_volume_width)) {
            findings.push_back(
                {validation_severity::info, wsi_iod_tags::imaged_volume_width,
                 "ImagedVolumeWidth (0048,0001) not present - physical "
                 "dimensions unavailable",
                 "WSI-INFO-001"});
        }
 
        if (!dataset.contains(wsi_iod_tags::imaged_volume_height)) {
            findings.push_back(
                {validation_severity::info, wsi_iod_tags::imaged_volume_height,
                 "ImagedVolumeHeight (0048,0002) not present - physical "
                 "dimensions unavailable",
                 "WSI-INFO-002"});
        }
 
        // Image Orientation (Slide) is Type 1C
        if (dataset.contains(wsi_iod_tags::total_pixel_matrix_columns) &&
            !dataset.contains(wsi_iod_tags::image_orientation_slide)) {
            findings.push_back(
                {validation_severity::warning,
                 wsi_iod_tags::image_orientation_slide,
                 "ImageOrientationSlide (0048,0102) missing - slide "
                 "orientation unknown",
                 "WSI-WARN-001"});
        }
    }
}

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ options_

wsi_validation_options kcenon::pacs::services::validation::wsi_iod_validator::options_

private

Definition at line 244 of file wsi_iod_validator.h.

Referenced by options(), set_options(), validate(), validate_general_series_module(), validate_general_study_module(), validate_image_pixel_module(), validate_optical_path_module(), validate_patient_module(), validate_sop_common_module(), and validate_wsi_image_module().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Validated Modules (PS3.3 Table A.32.8-1)

Mandatory Modules

User Optional Modules

Constructor & Destructor Documentation

◆ wsi_iod_validator() [1/2]

◆ wsi_iod_validator() [2/2]

Member Function Documentation

◆ check_modality()

◆ check_pixel_data_consistency()

◆ check_type1_attribute()

◆ check_type2_attribute()

◆ options()

◆ quick_check()

◆ set_options()

◆ validate()

◆ validate_general_series_module()

◆ validate_general_study_module()

◆ validate_image_pixel_module()

◆ validate_multiframe_dimension_module()

◆ validate_optical_path_module()

◆ validate_patient_module()

◆ validate_sop_common_module()

◆ validate_specimen_module()

◆ validate_wsi_image_module()

Member Data Documentation

◆ options_