kcenon::pacs::samples::test_data_generator Class Reference

#include <test_data_generator.h>

Collaboration diagram for kcenon::pacs::samples::test_data_generator:

Static Public Member Functions
static auto	create_ct_dataset (const patient_info &patient={}, const image_params &params={}) -> core::dicom_dataset
	Create a CT dataset with default or custom parameters.
static auto	create_mr_dataset (const patient_info &patient={}, image_params params={}) -> core::dicom_dataset
	Create an MR dataset with default or custom parameters.
static auto	create_cr_dataset (const patient_info &patient={}, image_params params={}) -> core::dicom_dataset
	Create a CR (Computed Radiography) dataset.
static auto	create_dx_dataset (const patient_info &patient={}, image_params params={}) -> core::dicom_dataset
	Create a DX (Digital X-Ray) dataset.
static auto	create_study (const patient_info &patient, const study_info &study, int series_count=1, int instances_per_series=5) -> std::vector< core::dicom_dataset >
	Generate a complete study with multiple series and instances.
static void	save_to_directory (const std::vector< core::dicom_dataset > &datasets, const std::filesystem::path &directory)
	Save datasets to a directory structure.
static auto	generate_uid (std::string_view root="1.2.410.200001.1.1") -> std::string
	Generate a unique DICOM UID.
static auto	current_date () -> std::string
	Get current date in DICOM format (YYYYMMDD)
static auto	current_time () -> std::string
	Get current time in DICOM format (HHMMSS.FFFFFF)

Static Private Member Functions
static auto	create_base_dataset (const patient_info &patient, const image_params &params) -> core::dicom_dataset
	Create a base dataset with common elements.
static auto	generate_pixel_data (uint16_t rows, uint16_t columns, uint16_t bits_allocated) -> std::vector< uint8_t >
	Generate test pixel data.

Static Private Attributes
static std::atomic< uint64_t >	uid_counter_ {0}
	Atomic counter for UID generation.

Detailed Description

Definition at line 94 of file test_data_generator.h.

Member Function Documentation

create_base_dataset()

auto kcenon::pacs::samples::test_data_generator::create_base_dataset ( const patient_info & patient, const image_params & params ) -> core::dicom_dataset

staticnodiscardprivate

Create a base dataset with common elements.

Parameters

patient	Patient information
params	Image parameters

Returns

Dataset with common elements populated

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 100 of file test_data_generator.cpp.

                                                     {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    core::dicom_dataset ds;
 
    // Patient Module
    ds.set_string(patient_name, vr::PN, patient.patient_name);
    ds.set_string(patient_id, vr::LO, patient.patient_id);
    ds.set_string(patient_birth_date, vr::DA, patient.birth_date);
    ds.set_string(patient_sex, vr::CS, patient.sex);
 
    // General Study Module
    auto study_uid = generate_uid();
    ds.set_string(study_instance_uid, vr::UI, study_uid);
    ds.set_string(study_date, vr::DA, current_date());
    ds.set_string(study_time, vr::TM, current_time());
    ds.set_string(accession_number, vr::SH, "ACC" + patient.patient_id);
    ds.set_string(study_id, vr::SH, "1");
    ds.set_string(study_description, vr::LO, "Test Study");
    ds.set_string(referring_physician_name, vr::PN, "REFERRING^PHYSICIAN");
 
    // General Series Module
    auto series_uid = generate_uid();
    ds.set_string(series_instance_uid, vr::UI, series_uid);
    ds.set_string(modality, vr::CS, params.modality);
    ds.set_numeric<int32_t>(series_number, vr::IS, 1);
    ds.set_string(series_date, vr::DA, current_date());
    ds.set_string(series_time, vr::TM, current_time());
    ds.set_string(series_description, vr::LO, params.modality + " Series");
 
    // Frame of Reference Module
    ds.set_string(frame_of_reference_uid, vr::UI, generate_uid());
 
    // General Equipment Module
    ds.set_string(manufacturer, vr::LO, "PACS System");
    ds.set_string(station_name, vr::SH, "SAMPLE_STATION");
    ds.set_string(manufacturers_model_name, vr::LO, "Sample Generator");
 
    // General Image Module
    auto instance_uid = generate_uid();
    ds.set_string(sop_instance_uid, vr::UI, instance_uid);
    ds.set_numeric<int32_t>(instance_number, vr::IS, 1);
    ds.set_string(content_date, vr::DA, current_date());
    ds.set_string(content_time, vr::TM, current_time());
    ds.set_string(image_type, vr::CS, "ORIGINAL\\PRIMARY\\AXIAL");
 
    // Image Pixel Module
    ds.set_numeric<uint16_t>(samples_per_pixel, vr::US, 1);
    ds.set_string(photometric_interpretation, vr::CS, params.photometric);
    ds.set_numeric<uint16_t>(rows, vr::US, params.rows);
    ds.set_numeric<uint16_t>(columns, vr::US, params.columns);
    ds.set_numeric<uint16_t>(bits_allocated, vr::US, params.bits_allocated);
    ds.set_numeric<uint16_t>(bits_stored, vr::US, params.bits_stored);
    ds.set_numeric<uint16_t>(high_bit, vr::US, params.high_bit);
    ds.set_numeric<uint16_t>(pixel_representation, vr::US, params.pixel_representation);
 
    // VOI LUT Module
    ds.set_string(window_center, vr::DS, std::to_string(params.window_center));
    ds.set_string(window_width, vr::DS, std::to_string(params.window_width));
 
    return ds;
}

References kcenon::pacs::core::dicom_dataset::set_numeric(), kcenon::pacs::core::dicom_dataset::set_string(), and vr.

Here is the call graph for this function:

create_cr_dataset()

auto kcenon::pacs::samples::test_data_generator::create_cr_dataset ( const patient_info & patient = {}, image_params params = {} ) -> core::dicom_dataset

staticnodiscard

Create a CR (Computed Radiography) dataset.

Parameters

patient	Patient information
params	Image parameters (default CR params if not provided)

Returns

A valid DICOM dataset for CR Storage

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 287 of file test_data_generator.cpp.

                                              {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    params.modality = "CR";
    params.photometric = "MONOCHROME2";
    params.rows = 2048;
    params.columns = 2048;
    params.bits_allocated = 16;
    params.bits_stored = 14;
    params.high_bit = 13;
    params.window_center = 8192.0;
    params.window_width = 16384.0;
 
    auto ds = create_base_dataset(patient, params);
 
    // SOP Class
    ds.set_string(sop_class_uid, vr::UI, std::string{sop_class::cr_image_storage});
 
    // Add pixel data
    auto pixel_bytes = generate_pixel_data(params.rows, params.columns,
                                           params.bits_allocated);
    ds.insert(core::dicom_element{pixel_data, vr::OW, pixel_bytes});
 
    return ds;
}

References kcenon::pacs::samples::sop_class::cr_image_storage, and vr.

create_ct_dataset()

auto kcenon::pacs::samples::test_data_generator::create_ct_dataset ( const patient_info & patient = {}, const image_params & params = {} ) -> core::dicom_dataset

staticnodiscard

Create a CT dataset with default or custom parameters.

Parameters

patient	Patient information (default if not provided)
params	Image parameters (default CT params if not provided)

Returns

A valid DICOM dataset for CT Storage

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 213 of file test_data_generator.cpp.

                                                     {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    image_params ct_params = params;
    ct_params.modality = "CT";
    ct_params.photometric = "MONOCHROME2";
    ct_params.window_center = 40.0;
    ct_params.window_width = 400.0;
 
    auto ds = create_base_dataset(patient, ct_params);
 
    // SOP Class
    ds.set_string(sop_class_uid, vr::UI, std::string{sop_class::ct_image_storage});
 
    // CT-specific attributes
    ds.set_string(rescale_intercept, vr::DS, "-1024");
    ds.set_string(rescale_slope, vr::DS, "1");
    ds.set_string(rescale_type, vr::LO, "HU");
    ds.set_string(pixel_spacing, vr::DS, "0.5\\0.5");
    ds.set_string(slice_location, vr::DS, "0.0");
    ds.set_string(image_position_patient, vr::DS, "0.0\\0.0\\0.0");
    ds.set_string(image_orientation_patient, vr::DS, "1.0\\0.0\\0.0\\0.0\\1.0\\0.0");
 
    // Add pixel data
    auto pixel_bytes = generate_pixel_data(ct_params.rows, ct_params.columns,
                                           ct_params.bits_allocated);
    ds.insert(core::dicom_element{pixel_data, vr::OW, pixel_bytes});
 
    return ds;
}

References kcenon::pacs::samples::image_params::bits_allocated, kcenon::pacs::samples::image_params::columns, kcenon::pacs::samples::sop_class::ct_image_storage, kcenon::pacs::samples::image_params::modality, kcenon::pacs::samples::image_params::photometric, kcenon::pacs::samples::image_params::rows, vr, kcenon::pacs::samples::image_params::window_center, and kcenon::pacs::samples::image_params::window_width.

create_dx_dataset()

auto kcenon::pacs::samples::test_data_generator::create_dx_dataset ( const patient_info & patient = {}, image_params params = {} ) -> core::dicom_dataset

staticnodiscard

Create a DX (Digital X-Ray) dataset.

Parameters

patient	Patient information
params	Image parameters (default DX params if not provided)

Returns

A valid DICOM dataset for DX Storage

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 321 of file test_data_generator.cpp.

                                              {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    params.modality = "DX";
    params.photometric = "MONOCHROME2";
    params.rows = 3000;
    params.columns = 3000;
    params.bits_allocated = 16;
    params.bits_stored = 14;
    params.high_bit = 13;
    params.window_center = 8192.0;
    params.window_width = 16384.0;
 
    auto ds = create_base_dataset(patient, params);
 
    // SOP Class
    ds.set_string(sop_class_uid, vr::UI, std::string{sop_class::dx_image_storage});
 
    // DX-specific attributes
    ds.set_string(pixel_spacing, vr::DS, "0.15\\0.15");
    ds.set_string(image_orientation_patient, vr::DS, "1.0\\0.0\\0.0\\0.0\\1.0\\0.0");
 
    // Add pixel data
    auto pixel_bytes = generate_pixel_data(params.rows, params.columns,
                                           params.bits_allocated);
    ds.insert(core::dicom_element{pixel_data, vr::OW, pixel_bytes});
 
    return ds;
}

References kcenon::pacs::samples::sop_class::dx_image_storage, and vr.

create_mr_dataset()

auto kcenon::pacs::samples::test_data_generator::create_mr_dataset ( const patient_info & patient = {}, image_params params = {} ) -> core::dicom_dataset

staticnodiscard

Create an MR dataset with default or custom parameters.

Parameters

patient	Patient information
params	Image parameters (default MR params if not provided)

Returns

A valid DICOM dataset for MR Storage

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 252 of file test_data_generator.cpp.

                                              {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    params.modality = "MR";
    params.photometric = "MONOCHROME2";
    params.window_center = 500.0;
    params.window_width = 1000.0;
 
    auto ds = create_base_dataset(patient, params);
 
    // SOP Class
    ds.set_string(sop_class_uid, vr::UI, std::string{sop_class::mr_image_storage});
 
    // MR-specific attributes
    ds.set_string(pixel_spacing, vr::DS, "1.0\\1.0");
    ds.set_string(slice_location, vr::DS, "0.0");
    ds.set_string(image_position_patient, vr::DS, "0.0\\0.0\\0.0");
    ds.set_string(image_orientation_patient, vr::DS, "1.0\\0.0\\0.0\\0.0\\1.0\\0.0");
 
    // Add pixel data
    auto pixel_bytes = generate_pixel_data(params.rows, params.columns,
                                           params.bits_allocated);
    ds.insert(core::dicom_element{pixel_data, vr::OW, pixel_bytes});
 
    return ds;
}

References kcenon::pacs::samples::sop_class::mr_image_storage, and vr.

create_study()

auto kcenon::pacs::samples::test_data_generator::create_study ( const patient_info & patient, const study_info & study, int series_count = 1, int instances_per_series = 5 ) -> std::vector<core::dicom_dataset>

staticnodiscard

Generate a complete study with multiple series and instances.

Parameters

patient	Patient information
study	Study information
series_count	Number of series to generate
instances_per_series	Number of instances per series

Returns

Vector of DICOM datasets comprising the study

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 359 of file test_data_generator.cpp.

                                                              {
 
    using namespace core::tags;
    using vr = encoding::vr_type;
 
    std::vector<core::dicom_dataset> datasets;
    datasets.reserve(static_cast<size_t>(series_count * instances_per_series));
 
    auto study_uid = study.study_uid.empty() ? generate_uid() : study.study_uid;
    auto study_dt = study.study_date.empty() ? current_date() : study.study_date;
    auto study_tm = study.study_time.empty() ? current_time() : study.study_time;
 
    for (int series_idx = 0; series_idx < series_count; ++series_idx) {
        auto series_uid = generate_uid();
        auto frame_uid = generate_uid();
 
        for (int instance_idx = 0; instance_idx < instances_per_series; ++instance_idx) {
            auto ds = create_ct_dataset(patient);
 
            // Override with study-level info
            ds.set_string(study_instance_uid, vr::UI, study_uid);
            ds.set_string(study_date, vr::DA, study_dt);
            ds.set_string(study_time, vr::TM, study_tm);
 
            if (!study.accession_number.empty()) {
                ds.set_string(accession_number, vr::SH, study.accession_number);
            }
            if (!study.description.empty()) {
                ds.set_string(study_description, vr::LO, study.description);
            }
            if (!study.referring_physician.empty()) {
                ds.set_string(referring_physician_name, vr::PN, study.referring_physician);
            }
 
            // Series-level info
            ds.set_string(series_instance_uid, vr::UI, series_uid);
            ds.set_numeric<int32_t>(series_number, vr::IS, series_idx + 1);
            ds.set_string(frame_of_reference_uid, vr::UI, frame_uid);
 
            // Instance-level info
            ds.set_string(sop_instance_uid, vr::UI, generate_uid());
            ds.set_numeric<int32_t>(instance_number, vr::IS, instance_idx + 1);
 
            // Slice location for 3D datasets
            double slice_loc = static_cast<double>(instance_idx) * 5.0;
            ds.set_string(slice_location, vr::DS, std::to_string(slice_loc));
            ds.set_string(image_position_patient, vr::DS,
                "0.0\\0.0\\" + std::to_string(slice_loc));
 
            datasets.push_back(std::move(ds));
        }
    }
 
    return datasets;
}

References vr.

current_date()

auto kcenon::pacs::samples::test_data_generator::current_date ( ) -> std::string

staticnodiscard

Get current date in DICOM format (YYYYMMDD)

Returns

Current date string

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 57 of file test_data_generator.cpp.

                                                    {
    auto now = std::chrono::system_clock::now();
    auto time_t = std::chrono::system_clock::to_time_t(now);
    std::tm tm{};
#ifdef _WIN32
    localtime_s(&tm, &time_t);
#else
    localtime_r(&time_t, &tm);
#endif
 
    std::ostringstream oss;
    oss << std::setfill('0')
        << std::setw(4) << (tm.tm_year + 1900)
        << std::setw(2) << (tm.tm_mon + 1)
        << std::setw(2) << tm.tm_mday;
    return oss.str();
}

current_time()

auto kcenon::pacs::samples::test_data_generator::current_time ( ) -> std::string

staticnodiscard

Get current time in DICOM format (HHMMSS.FFFFFF)

Returns

Current time string

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 75 of file test_data_generator.cpp.

                                                    {
    auto now = std::chrono::system_clock::now();
    auto time_t = std::chrono::system_clock::to_time_t(now);
    auto ms = std::chrono::duration_cast<std::chrono::microseconds>(
        now.time_since_epoch()).count() % 1000000;
    std::tm tm{};
#ifdef _WIN32
    localtime_s(&tm, &time_t);
#else
    localtime_r(&time_t, &tm);
#endif
 
    std::ostringstream oss;
    oss << std::setfill('0')
        << std::setw(2) << tm.tm_hour
        << std::setw(2) << tm.tm_min
        << std::setw(2) << tm.tm_sec
        << "." << std::setw(6) << ms;
    return oss.str();
}

generate_pixel_data()

auto kcenon::pacs::samples::test_data_generator::generate_pixel_data ( uint16_t rows, uint16_t columns, uint16_t bits_allocated ) -> std::vector<uint8_t>

staticnodiscardprivate

Generate test pixel data.

Parameters

rows	Number of rows
columns	Number of columns
bits_allocated	Bits allocated per pixel

Returns

Vector of pixel data bytes

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 171 of file test_data_generator.cpp.

                                               {
 
    size_t bytes_per_pixel = bits_alloc / 8;
    size_t total_pixels = static_cast<size_t>(row_count) * col_count;
    std::vector<uint8_t> data(total_pixels * bytes_per_pixel);
 
    // Generate a simple gradient pattern
    uint16_t max_value = static_cast<uint16_t>((1 << (bits_alloc > 16 ? 16 : bits_alloc)) - 1);
 
    for (uint16_t y = 0; y < row_count; ++y) {
        for (uint16_t x = 0; x < col_count; ++x) {
            size_t idx = (static_cast<size_t>(y) * col_count + x) * bytes_per_pixel;
 
            // Create a circular gradient pattern
            double cx = col_count / 2.0;
            double cy = row_count / 2.0;
            double dx = x - cx;
            double dy = y - cy;
            double dist = std::sqrt(dx * dx + dy * dy);
            double max_dist = std::sqrt(cx * cx + cy * cy);
            double normalized = 1.0 - (dist / max_dist);
 
            uint16_t value = static_cast<uint16_t>(normalized * max_value * 0.8);
 
            // Store as little-endian
            data[idx] = static_cast<uint8_t>(value & 0xFF);
            if (bytes_per_pixel > 1) {
                data[idx + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
            }
        }
    }
 
    return data;
}

generate_uid()

auto kcenon::pacs::samples::test_data_generator::generate_uid ( std::string_view root = "1.2.410.200001.1.1" ) -> std::string

staticnodiscard

Generate a unique DICOM UID.

Parameters

root	UID root (default: pacs_system sample root)

Returns

A unique UID string

Generated UIDs follow the format: root.timestamp.counter Thread-safe using atomic counter.

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 41 of file test_data_generator.cpp.

                                                                       {
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::duration_cast<std::chrono::microseconds>(
        now.time_since_epoch()).count();
 
    auto counter = uid_counter_.fetch_add(1, std::memory_order_relaxed);
 
    std::ostringstream oss;
    oss << root << "." << time << "." << counter;
    return oss.str();
}

save_to_directory()

void kcenon::pacs::samples::test_data_generator::save_to_directory ( const std::vector< core::dicom_dataset > & datasets, const std::filesystem::path & directory )

static

Save datasets to a directory structure.

Parameters

datasets	The datasets to save
directory	Target directory path

Creates a hierarchical directory structure: directory/PatientID/StudyUID/SeriesUID/InstanceUID.dcm

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 423 of file test_data_generator.cpp.

                                        {
 
    using namespace core::tags;
    namespace fs = std::filesystem;
 
    fs::create_directories(directory);
 
    for (const auto& ds : datasets) {
        auto pat_id = ds.get_string(patient_id, "UNKNOWN");
        auto study_uid_str = ds.get_string(study_instance_uid, "UNKNOWN");
        auto series_uid_str = ds.get_string(series_instance_uid, "UNKNOWN");
        auto instance_uid_str = ds.get_string(sop_instance_uid, "UNKNOWN");
 
        // Create hierarchical path
        auto path = directory / pat_id / study_uid_str / series_uid_str;
        fs::create_directories(path);
 
        auto file_path = path / (instance_uid_str + ".dcm");
 
        // Create DICOM file and save
        auto file = core::dicom_file::create(
            ds, encoding::transfer_syntax::explicit_vr_little_endian);
        auto result = file.save(file_path);
 
        if (!result.is_ok()) {
            throw std::runtime_error("Failed to save DICOM file: " +
                                     file_path.string());
        }
    }
}

References kcenon::pacs::core::dicom_file::create(), and kcenon::pacs::encoding::transfer_syntax::explicit_vr_little_endian.

Here is the call graph for this function:

Member Data Documentation

uid_counter_

std::atomic< uint64_t > kcenon::pacs::samples::test_data_generator::uid_counter_ {0}

staticprivate

Atomic counter for UID generation.

Examples

/home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 229 of file test_data_generator.h.

---

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

• examples/tutorials/common/test_data_generator.h
• examples/tutorials/common/test_data_generator.cpp