#include <mini_pacs.h>

Collaboration diagram for kcenon::pacs::samples::mini_pacs:

Public Member Functions
	mini_pacs (const mini_pacs_config &config)
	Construct Mini PACS with configuration.

	~mini_pacs ()
	Destructor - ensures clean shutdown.

	mini_pacs (const mini_pacs &)=delete

mini_pacs &	operator= (const mini_pacs &)=delete

	mini_pacs (mini_pacs &&)=delete

mini_pacs &	operator= (mini_pacs &&)=delete

bool	start ()
	Start the PACS server.

void	stop ()
	Stop the PACS server.

void	wait ()
	Block until server shutdown.

bool	is_running () const noexcept
	Check if server is running.

const mini_pacs_statistics &	statistics () const noexcept
	Get current statistics.

void	add_worklist_item (const worklist_entry &item)
	Add a worklist item for MWL queries.

void	clear_worklist ()
	Clear all worklist items.

std::vector< worklist_entry >	get_worklist_items () const
	Get current worklist items.

const mini_pacs_config &	config () const noexcept
	Get the configuration.

Private Member Functions
void	initialize_storage ()

void	initialize_services ()

void	configure_server ()

void	setup_event_handlers ()

services::storage_status	handle_store (const core::dicom_dataset &dataset, const std::string &calling_ae, const std::string &sop_class_uid, const std::string &sop_instance_uid)

bool	update_index (const core::dicom_dataset &dataset, const std::filesystem::path &file_path)

std::vector< core::dicom_dataset >	handle_query (services::query_level level, const core::dicom_dataset &query_keys, const std::string &calling_ae)

std::vector< core::dicom_file >	handle_retrieve (const core::dicom_dataset &query_keys)

std::optional< std::pair< std::string, uint16_t > >	resolve_destination (const std::string &ae_title)

std::vector< core::dicom_dataset >	handle_worklist_query (const core::dicom_dataset &query_keys, const std::string &calling_ae)

core::dicom_dataset	create_worklist_response (const worklist_entry &item)

network::Result< std::monostate >	handle_mpps_create (const services::mpps_instance &instance)

network::Result< std::monostate >	handle_mpps_set (const std::string &sop_instance_uid, const core::dicom_dataset &modifications, services::mpps_status new_status)

Private Attributes
mini_pacs_config	config_

mini_pacs_statistics	stats_

std::shared_ptr< storage::file_storage >	file_storage_

std::shared_ptr< storage::index_database >	index_db_

std::shared_ptr< services::verification_scp >	verification_scp_

std::shared_ptr< services::storage_scp >	storage_scp_

std::shared_ptr< services::query_scp >	query_scp_

std::shared_ptr< services::retrieve_scp >	retrieve_scp_

std::shared_ptr< services::worklist_scp >	worklist_scp_

std::shared_ptr< services::mpps_scp >	mpps_scp_

std::unique_ptr< network::dicom_server >	server_

std::atomic< bool >	running_ {false}

std::mutex	worklist_mutex_

std::vector< worklist_entry >	worklist_items_

std::mutex	mpps_mutex_

std::vector< mpps_entry >	mpps_instances_

Detailed Description

Definition at line 211 of file mini_pacs.h.

Constructor & Destructor Documentation

◆ mini_pacs() [1/3]

kcenon::pacs::samples::mini_pacs::mini_pacs ( const mini_pacs_config & config )

explicit

Construct Mini PACS with configuration.

Parameters

config Configuration options

Definition at line 24 of file mini_pacs.cpp.

    : config_(config) {
    initialize_storage();
    initialize_services();
    configure_server();
    setup_event_handlers();
}

References configure_server(), initialize_services(), initialize_storage(), and setup_event_handlers().

Here is the call graph for this function:

◆ ~mini_pacs()

kcenon::pacs::samples::mini_pacs::~mini_pacs ( )

Destructor - ensures clean shutdown.

Definition at line 32 of file mini_pacs.cpp.

                      {
    stop();
}

References stop().

Here is the call graph for this function:

◆ mini_pacs() [2/3]

kcenon::pacs::samples::mini_pacs::mini_pacs ( const mini_pacs & )

delete

◆ mini_pacs() [3/3]

kcenon::pacs::samples::mini_pacs::mini_pacs ( mini_pacs && )

delete

Member Function Documentation

◆ add_worklist_item()

void kcenon::pacs::samples::mini_pacs::add_worklist_item ( const worklist_entry & item )

Add a worklist item for MWL queries.

Parameters

item	The worklist entry to add

Definition at line 88 of file mini_pacs.cpp.

                                                            {
    std::lock_guard<std::mutex> lock(worklist_mutex_);
    worklist_items_.push_back(item);
}

References worklist_items_, and worklist_mutex_.

◆ clear_worklist()

void kcenon::pacs::samples::mini_pacs::clear_worklist ( )

Clear all worklist items.

Definition at line 93 of file mini_pacs.cpp.

                               {
    std::lock_guard<std::mutex> lock(worklist_mutex_);
    worklist_items_.clear();
}

References worklist_items_, and worklist_mutex_.

◆ config()

const mini_pacs_config & kcenon::pacs::samples::mini_pacs::config ( ) const

nodiscardnoexcept

Get the configuration.

Returns: Reference to configuration

Definition at line 107 of file mini_pacs.cpp.

                                                         {
    return config_;
}

References config_.

◆ configure_server()

void kcenon::pacs::samples::mini_pacs::configure_server ( )

private

Definition at line 187 of file mini_pacs.cpp.

                                 {
    network::server_config server_config;
    server_config.ae_title = config_.ae_title;
    server_config.port = config_.port;
    server_config.max_associations = config_.max_associations;
    server_config.idle_timeout = std::chrono::seconds(60);
    server_config.max_pdu_size = 65536;
    server_config.implementation_class_uid = "1.2.410.200001.1.4";
    server_config.implementation_version_name = "MINI_PACS_4.0";
 
    server_ = std::make_unique<network::dicom_server>(server_config);
 
    // Register all services
    server_->register_service(verification_scp_);
    server_->register_service(storage_scp_);
    server_->register_service(query_scp_);
    server_->register_service(retrieve_scp_);
 
    if (worklist_scp_) {
        server_->register_service(worklist_scp_);
    }
    if (mpps_scp_) {
        server_->register_service(mpps_scp_);
    }
}

References kcenon::pacs::samples::mini_pacs_config::ae_title, kcenon::pacs::samples::server_config::ae_title, config_, kcenon::pacs::samples::server_config::idle_timeout, kcenon::pacs::samples::mini_pacs_config::max_associations, kcenon::pacs::samples::server_config::max_associations, mpps_scp_, kcenon::pacs::samples::mini_pacs_config::port, kcenon::pacs::samples::server_config::port, query_scp_, retrieve_scp_, server_, storage_scp_, verification_scp_, and worklist_scp_.

Referenced by mini_pacs().

Here is the caller graph for this function:

◆ create_worklist_response()

core::dicom_dataset kcenon::pacs::samples::mini_pacs::create_worklist_response ( const worklist_entry & item )

private

Definition at line 598 of file mini_pacs.cpp.

                                                                                {
    core::dicom_dataset ds;
 
    // Patient level
    ds.set_string(tags::patient_id, encoding::vr_type::LO, item.patient_id);
    ds.set_string(tags::patient_name, encoding::vr_type::PN, item.patient_name);
    ds.set_string(tags::patient_birth_date, encoding::vr_type::DA, item.patient_birth_date);
    ds.set_string(tags::patient_sex, encoding::vr_type::CS, item.patient_sex);
 
    // Study level
    ds.set_string(tags::study_instance_uid, encoding::vr_type::UI, item.study_uid);
    ds.set_string(tags::accession_number, encoding::vr_type::SH, item.accession_number);
    ds.set_string(tags::referring_physician_name, encoding::vr_type::PN, item.referring_physician);
 
    // Scheduled Procedure Step Sequence would be set here
    // For simplicity, we set flat attributes
    ds.set_string(tags::modality, encoding::vr_type::CS, item.modality);
    ds.set_string(tags::scheduled_procedure_step_start_date, encoding::vr_type::DA, item.scheduled_date);
    ds.set_string(tags::scheduled_procedure_step_start_time, encoding::vr_type::TM, item.scheduled_time);
    ds.set_string(tags::scheduled_procedure_step_id, encoding::vr_type::SH, item.step_id);
    ds.set_string(tags::scheduled_procedure_step_description, encoding::vr_type::LO, item.procedure_description);
    ds.set_string(tags::scheduled_station_ae_title, encoding::vr_type::AE, item.scheduled_station_ae);
 
    return ds;
}

Referenced by handle_worklist_query().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_worklist_items()

std::vector< worklist_entry > kcenon::pacs::samples::mini_pacs::get_worklist_items ( ) const

nodiscard

Get current worklist items.

Returns: Vector of worklist entries

Definition at line 98 of file mini_pacs.cpp.

                                                              {
    std::lock_guard<std::mutex> lock(worklist_mutex_);
    return worklist_items_;
}

References worklist_items_, and worklist_mutex_.

◆ handle_mpps_create()

network::Result< std::monostate > kcenon::pacs::samples::mini_pacs::handle_mpps_create ( const services::mpps_instance & instance )

private

Definition at line 628 of file mini_pacs.cpp.

                                           {
 
    stats_.mpps_create_count++;
 
    mpps_entry entry;
    entry.sop_instance_uid = instance.sop_instance_uid;
    entry.status = "IN PROGRESS";
    entry.station_ae = instance.station_ae;
    entry.data = instance.data;
 
    {
        std::lock_guard<std::mutex> lock(mpps_mutex_);
        mpps_instances_.push_back(std::move(entry));
    }
 
    if (config_.verbose_logging) {
        std::cout << "[MPPS N-CREATE] UID: " << instance.sop_instance_uid
                  << " Station: " << instance.station_ae << "\n";
    }
 
    return network::Result<std::monostate>::ok({});
}

References config_, kcenon::pacs::samples::mpps_entry::data, kcenon::pacs::services::mpps_instance::data, kcenon::pacs::samples::mini_pacs_statistics::mpps_create_count, mpps_instances_, mpps_mutex_, kcenon::pacs::samples::mpps_entry::sop_instance_uid, kcenon::pacs::services::mpps_instance::sop_instance_uid, kcenon::pacs::samples::mpps_entry::station_ae, kcenon::pacs::services::mpps_instance::station_ae, stats_, kcenon::pacs::samples::mpps_entry::status, and kcenon::pacs::samples::mini_pacs_config::verbose_logging.

Referenced by initialize_services().

Here is the caller graph for this function:

◆ handle_mpps_set()

network::Result< std::monostate > kcenon::pacs::samples::mini_pacs::handle_mpps_set	(	const std::string &	sop_instance_uid,
		const core::dicom_dataset &	modifications,
		services::mpps_status	new_status )

private

Definition at line 652 of file mini_pacs.cpp.

                                    {
 
    stats_.mpps_set_count++;
 
    std::lock_guard<std::mutex> lock(mpps_mutex_);
 
    for (auto& entry : mpps_instances_) {
        if (entry.sop_instance_uid == sop_instance_uid) {
            entry.status = std::string(services::to_string(new_status));
 
            if (config_.verbose_logging) {
                std::cout << "[MPPS N-SET] UID: " << sop_instance_uid
                          << " Status: " << entry.status << "\n";
            }
 
            return network::Result<std::monostate>::ok({});
        }
    }
 
    return kcenon::pacs::pacs_error<std::monostate>(
        kcenon::pacs::error_codes::instance_not_found,
        "MPPS instance not found: " + sop_instance_uid);
}

References config_, kcenon::pacs::error_codes::instance_not_found, mpps_instances_, mpps_mutex_, kcenon::pacs::samples::mini_pacs_statistics::mpps_set_count, kcenon::pacs::pacs_error(), stats_, kcenon::pacs::services::to_string(), and kcenon::pacs::samples::mini_pacs_config::verbose_logging.

Referenced by initialize_services().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_query()

std::vector< core::dicom_dataset > kcenon::pacs::samples::mini_pacs::handle_query	(	services::query_level	level,
		const core::dicom_dataset &	query_keys,
		const std::string &	calling_ae )

private

Definition at line 358 of file mini_pacs.cpp.

                        {
 
    stats_.c_find_count++;
 
    std::vector<core::dicom_dataset> results;
 
    switch (level) {
        case services::query_level::patient: {
            storage::patient_query pq;
            auto pid = query_keys.get_string(tags::patient_id);
            auto pname = query_keys.get_string(tags::patient_name);
            if (!pid.empty()) pq.patient_id = pid;
            if (!pname.empty()) pq.patient_name = pname;
 
            auto patients = index_db_->search_patients(pq);
 
            if (patients.is_ok()) {
                for (const auto& p : patients.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(tags::patient_id, encoding::vr_type::LO, p.patient_id);
                    ds.set_string(tags::patient_name, encoding::vr_type::PN, p.patient_name);
                    ds.set_string(tags::patient_birth_date, encoding::vr_type::DA, p.birth_date);
                    ds.set_string(tags::patient_sex, encoding::vr_type::CS, p.sex);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::study: {
            storage::study_query sq;
            auto pid = query_keys.get_string(tags::patient_id);
            auto study_uid = query_keys.get_string(tags::study_instance_uid);
            auto study_date = query_keys.get_string(tags::study_date);
            auto accession = query_keys.get_string(tags::accession_number);
            if (!pid.empty()) sq.patient_id = pid;
            if (!study_uid.empty()) sq.study_uid = study_uid;
            if (!study_date.empty()) sq.study_date = study_date;
            if (!accession.empty()) sq.accession_number = accession;
 
            auto studies = index_db_->search_studies(sq);
 
            if (studies.is_ok()) {
                for (const auto& s : studies.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(tags::study_instance_uid, encoding::vr_type::UI, s.study_uid);
                    ds.set_string(tags::study_id, encoding::vr_type::SH, s.study_id);
                    ds.set_string(tags::study_date, encoding::vr_type::DA, s.study_date);
                    ds.set_string(tags::study_time, encoding::vr_type::TM, s.study_time);
                    ds.set_string(tags::accession_number, encoding::vr_type::SH, s.accession_number);
                    ds.set_string(tags::study_description, encoding::vr_type::LO, s.study_description);
                    ds.set_string(tags::referring_physician_name, encoding::vr_type::PN, s.referring_physician);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::series: {
            storage::series_query sq;
            auto study_uid = query_keys.get_string(tags::study_instance_uid);
            auto series_uid = query_keys.get_string(tags::series_instance_uid);
            auto modality = query_keys.get_string(tags::modality);
            if (!study_uid.empty()) sq.study_uid = study_uid;
            if (!series_uid.empty()) sq.series_uid = series_uid;
            if (!modality.empty()) sq.modality = modality;
 
            auto series = index_db_->search_series(sq);
 
            if (series.is_ok()) {
                for (const auto& ser : series.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(tags::series_instance_uid, encoding::vr_type::UI, ser.series_uid);
                    ds.set_string(tags::modality, encoding::vr_type::CS, ser.modality);
                    if (ser.series_number.has_value()) {
                        ds.set_numeric(tags::series_number, encoding::vr_type::IS, ser.series_number.value());
                    }
                    ds.set_string(tags::series_description, encoding::vr_type::LO, ser.series_description);
                    ds.set_string(tags::station_name, encoding::vr_type::SH, ser.station_name);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::image: {
            storage::instance_query iq;
            auto series_uid = query_keys.get_string(tags::series_instance_uid);
            auto sop_uid = query_keys.get_string(tags::sop_instance_uid);
            if (!series_uid.empty()) iq.series_uid = series_uid;
            if (!sop_uid.empty()) iq.sop_uid = sop_uid;
 
            auto instances = index_db_->search_instances(iq);
 
            if (instances.is_ok()) {
                for (const auto& inst : instances.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(tags::sop_instance_uid, encoding::vr_type::UI, inst.sop_uid);
                    ds.set_string(tags::sop_class_uid, encoding::vr_type::UI, inst.sop_class_uid);
                    if (inst.instance_number.has_value()) {
                        ds.set_numeric(tags::instance_number, encoding::vr_type::IS, inst.instance_number.value());
                    }
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
    }
 
    if (config_.verbose_logging) {
        std::cout << "[C-FIND] Level: " << to_string(level)
                  << " Results: " << results.size() << "\n";
    }
 
    return results;
}

Referenced by initialize_services().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_retrieve()

std::vector< core::dicom_file > kcenon::pacs::samples::mini_pacs::handle_retrieve ( const core::dicom_dataset & query_keys )

private

Definition at line 482 of file mini_pacs.cpp.

                                         {
 
    std::vector<core::dicom_file> files;
 
    // Determine query level from keys
    auto study_uid = query_keys.get_string(tags::study_instance_uid);
    auto series_uid = query_keys.get_string(tags::series_instance_uid);
    auto sop_uid = query_keys.get_string(tags::sop_instance_uid);
 
    std::vector<storage::instance_record> instances;
 
    if (!sop_uid.empty()) {
        // Instance level retrieve
        storage::instance_query iq;
        iq.sop_uid = sop_uid;
        auto result = index_db_->search_instances(iq);
        if (result.is_ok()) {
            instances = result.value();
        }
    } else if (!series_uid.empty()) {
        // Series level retrieve
        storage::instance_query iq;
        iq.series_uid = series_uid;
        auto result = index_db_->search_instances(iq);
        if (result.is_ok()) {
            instances = result.value();
        }
    } else if (!study_uid.empty()) {
        // Study level retrieve - get all series first
        storage::series_query sq;
        sq.study_uid = study_uid;
        auto series_result = index_db_->search_series(sq);
        if (series_result.is_ok()) {
            for (const auto& ser : series_result.value()) {
                storage::instance_query iq;
                iq.series_uid = ser.series_uid;
                auto inst_result = index_db_->search_instances(iq);
                if (inst_result.is_ok()) {
                    for (const auto& inst : inst_result.value()) {
                        instances.push_back(inst);
                    }
                }
            }
        }
    }
 
    // Load files from disk
    for (const auto& inst : instances) {
        auto file_result = core::dicom_file::open(inst.file_path);
        if (file_result.is_ok()) {
            files.push_back(std::move(file_result.value()));
        }
    }
 
    stats_.c_move_count++;
 
    if (config_.verbose_logging) {
        std::cout << "[C-MOVE/C-GET] Files: " << files.size() << "\n";
    }
 
    return files;
}

References kcenon::pacs::samples::mini_pacs_statistics::c_move_count, config_, kcenon::pacs::core::dicom_dataset::get_string(), index_db_, kcenon::pacs::core::dicom_file::open(), kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::storage::instance_query::series_uid, kcenon::pacs::core::tags::sop_instance_uid, kcenon::pacs::storage::instance_query::sop_uid, stats_, kcenon::pacs::core::tags::study_instance_uid, kcenon::pacs::storage::series_query::study_uid, and kcenon::pacs::samples::mini_pacs_config::verbose_logging.

Referenced by initialize_services().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_store()

services::storage_status kcenon::pacs::samples::mini_pacs::handle_store	(	const core::dicom_dataset &	dataset,
		const std::string &	calling_ae,
		const std::string &	sop_class_uid,
		const std::string &	sop_instance_uid )

private

Definition at line 244 of file mini_pacs.cpp.

                                       {
 
    stats_.c_store_count++;
 
    if (config_.verbose_logging) {
        std::cout << "[C-STORE] From: " << calling_ae
                  << " Patient: " << dataset.get_string(tags::patient_name)
                  << " Modality: " << dataset.get_string(tags::modality) << "\n";
    }
 
    // Store to filesystem
    auto store_result = file_storage_->store(dataset);
    if (store_result.is_err()) {
        std::cerr << "  Storage failed: " << store_result.error().message << "\n";
        return services::storage_status::storage_error;
    }
 
    // Get stored file path and update index
    auto file_path = file_storage_->get_file_path(sop_instance_uid);
    if (!update_index(dataset, file_path)) {
        return services::storage_status::storage_error;
    }
 
    stats_.bytes_received += std::filesystem::exists(file_path)
        ? std::filesystem::file_size(file_path)
        : 0;
 
    return services::storage_status::success;
}

References kcenon::pacs::samples::mini_pacs_statistics::bytes_received, kcenon::pacs::samples::mini_pacs_statistics::c_store_count, config_, file_storage_, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::tags::modality, kcenon::pacs::core::tags::patient_name, stats_, kcenon::pacs::services::storage_error, kcenon::pacs::services::success, update_index(), and kcenon::pacs::samples::mini_pacs_config::verbose_logging.

Referenced by initialize_services().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_worklist_query()

std::vector< core::dicom_dataset > kcenon::pacs::samples::mini_pacs::handle_worklist_query	(	const core::dicom_dataset &	query_keys,
		const std::string &	calling_ae )

private

Definition at line 561 of file mini_pacs.cpp.

                        {
 
    stats_.mwl_count++;
 
    std::vector<core::dicom_dataset> results;
 
    // Extract filter criteria
    auto filter_modality = query_keys.get_string(tags::modality);
    auto filter_date = query_keys.get_string(tags::scheduled_procedure_step_start_date);
    auto filter_patient_id = query_keys.get_string(tags::patient_id);
 
    std::lock_guard<std::mutex> lock(worklist_mutex_);
 
    for (const auto& item : worklist_items_) {
        // Apply filters
        if (!filter_modality.empty() && item.modality != filter_modality) {
            continue;
        }
        if (!filter_date.empty() && item.scheduled_date != filter_date) {
            continue;
        }
        if (!filter_patient_id.empty() && item.patient_id != filter_patient_id) {
            continue;
        }
 
        results.push_back(create_worklist_response(item));
    }
 
    if (config_.verbose_logging) {
        std::cout << "[MWL] Results: " << results.size() << "\n";
    }
 
    return results;
}

References config_, create_worklist_response(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::tags::modality, kcenon::pacs::samples::mini_pacs_statistics::mwl_count, kcenon::pacs::core::tags::patient_id, kcenon::pacs::core::tags::scheduled_procedure_step_start_date, stats_, kcenon::pacs::samples::mini_pacs_config::verbose_logging, worklist_items_, and worklist_mutex_.

Referenced by initialize_services().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_services()

void kcenon::pacs::samples::mini_pacs::initialize_services ( )

private

Definition at line 139 of file mini_pacs.cpp.

                                    {
    // Verification SCP (C-ECHO)
    verification_scp_ = std::make_shared<services::verification_scp>();
 
    // Storage SCP (C-STORE)
    services::storage_scp_config scp_config;
    storage_scp_ = std::make_shared<services::storage_scp>(scp_config);
    storage_scp_->set_handler(
        [this](const auto& ds, const auto& ae, const auto& sop_class,
               const auto& sop_instance) {
            return handle_store(ds, ae, sop_class, sop_instance);
        });
 
    // Query SCP (C-FIND)
    query_scp_ = std::make_shared<services::query_scp>();
    query_scp_->set_handler(
        [this](auto level, const auto& keys, const auto& ae) {
            return handle_query(level, keys, ae);
        });
 
    // Retrieve SCP (C-MOVE/C-GET)
    retrieve_scp_ = std::make_shared<services::retrieve_scp>();
    retrieve_scp_->set_retrieve_handler(
        [this](const auto& keys) { return handle_retrieve(keys); });
    retrieve_scp_->set_destination_resolver(
        [this](const auto& ae) { return resolve_destination(ae); });
 
    // Worklist SCP (MWL C-FIND)
    if (config_.enable_worklist) {
        worklist_scp_ = std::make_shared<services::worklist_scp>();
        worklist_scp_->set_handler(
            [this](const auto& keys, const auto& ae) {
                return handle_worklist_query(keys, ae);
            });
    }
 
    // MPPS SCP (N-CREATE/N-SET)
    if (config_.enable_mpps) {
        mpps_scp_ = std::make_shared<services::mpps_scp>();
        mpps_scp_->set_create_handler(
            [this](const auto& inst) { return handle_mpps_create(inst); });
        mpps_scp_->set_set_handler(
            [this](const auto& uid, const auto& mods, auto status) {
                return handle_mpps_set(uid, mods, status);
            });
    }
}

References config_, kcenon::pacs::samples::mini_pacs_config::enable_mpps, kcenon::pacs::samples::mini_pacs_config::enable_worklist, handle_mpps_create(), handle_mpps_set(), handle_query(), handle_retrieve(), handle_store(), handle_worklist_query(), mpps_scp_, query_scp_, resolve_destination(), retrieve_scp_, storage_scp_, uid, verification_scp_, and worklist_scp_.

Referenced by mini_pacs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_storage()

void kcenon::pacs::samples::mini_pacs::initialize_storage ( )

private

Definition at line 115 of file mini_pacs.cpp.

                                   {
    // Create storage directories
    std::filesystem::create_directories(config_.storage_path);
 
    // Configure file storage
    storage::file_storage_config fs_config;
    fs_config.root_path = config_.storage_path;
    fs_config.naming = storage::naming_scheme::uid_hierarchical;
    fs_config.duplicate = storage::duplicate_policy::replace;
    fs_config.create_directories = true;
    fs_config.file_extension = ".dcm";
 
    file_storage_ = std::make_shared<storage::file_storage>(fs_config);
 
    // Initialize index database
    auto db_path = config_.storage_path / "index.db";
    auto db_result = storage::index_database::open(db_path.string());
    if (db_result.is_err()) {
        throw std::runtime_error("Failed to open index database: " +
                                 db_result.error().message);
    }
    index_db_ = std::move(db_result.value());
}

Referenced by mini_pacs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_running()

bool kcenon::pacs::samples::mini_pacs::is_running ( ) const

nodiscardnoexcept

Check if server is running.

Returns: true if running

Definition at line 72 of file mini_pacs.cpp.

                                          {
    return running_;
}

References running_.

◆ operator=() [1/2]

mini_pacs & kcenon::pacs::samples::mini_pacs::operator= ( const mini_pacs & )

delete

◆ operator=() [2/2]

mini_pacs & kcenon::pacs::samples::mini_pacs::operator= ( mini_pacs && )

delete

◆ resolve_destination()

std::optional< std::pair< std::string, uint16_t > > kcenon::pacs::samples::mini_pacs::resolve_destination ( const std::string & ae_title )

private

Definition at line 546 of file mini_pacs.cpp.

                               {
    // Simple in-memory AE resolution
    // In a production system, this would query a configuration database
    if (ae_title == config_.ae_title) {
        return std::make_pair("localhost", config_.port);
    }
    // Return nullopt for unknown destinations
    return std::nullopt;
}

References kcenon::pacs::samples::mini_pacs_config::ae_title, config_, and kcenon::pacs::samples::mini_pacs_config::port.

Referenced by initialize_services().

Here is the caller graph for this function:

◆ setup_event_handlers()

void kcenon::pacs::samples::mini_pacs::setup_event_handlers ( )

private

Definition at line 213 of file mini_pacs.cpp.

                                     {
    server_->on_association_established(
        [this](const network::association& assoc) {
            stats_.associations_total++;
            stats_.associations_active++;
            if (config_.verbose_logging) {
                std::cout << "[CONNECT] " << assoc.calling_ae()
                          << " -> " << assoc.called_ae()
                          << " (active: " << stats_.associations_active << ")\n";
            }
        });
 
    server_->on_association_released(
        [this](const network::association& assoc) {
            stats_.associations_active--;
            if (config_.verbose_logging) {
                std::cout << "[RELEASE] " << assoc.calling_ae()
                          << " (active: " << stats_.associations_active << ")\n";
            }
        });
 
    server_->on_error(
        [this](const std::string& msg) {
            std::cerr << "[ERROR] " << msg << "\n";
        });
}

References kcenon::pacs::samples::mini_pacs_statistics::associations_active, kcenon::pacs::samples::mini_pacs_statistics::associations_total, kcenon::pacs::network::association::called_ae(), kcenon::pacs::network::association::calling_ae(), config_, server_, stats_, and kcenon::pacs::samples::mini_pacs_config::verbose_logging.

Referenced by mini_pacs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start()

bool kcenon::pacs::samples::mini_pacs::start ( )

nodiscard

Start the PACS server.

Returns: true if started successfully

Definition at line 40 of file mini_pacs.cpp.

                      {
    if (running_) {
        return true;
    }
 
    auto result = server_->start();
    if (result.is_err()) {
        std::cerr << "Failed to start server: " << result.error().message << "\n";
        return false;
    }
 
    running_ = true;
    return true;
}

References running_, and server_.

◆ statistics()

const mini_pacs_statistics & kcenon::pacs::samples::mini_pacs::statistics ( ) const

nodiscardnoexcept

Get current statistics.

Returns: Reference to statistics structure

Definition at line 80 of file mini_pacs.cpp.

                                                                 {
    return stats_;
}

References stats_.

◆ stop()

void kcenon::pacs::samples::mini_pacs::stop ( )

Stop the PACS server.

Definition at line 55 of file mini_pacs.cpp.

                     {
    if (!running_) {
        return;
    }
 
    running_ = false;
    if (server_) {
        server_->stop();
    }
}

References running_, and server_.

Referenced by ~mini_pacs().

Here is the caller graph for this function:

◆ update_index()

bool kcenon::pacs::samples::mini_pacs::update_index	(	const core::dicom_dataset &	dataset,
		const std::filesystem::path &	file_path )

private

Definition at line 278 of file mini_pacs.cpp.

                                        {
 
    // Patient
    auto patient_result = index_db_->upsert_patient(
        ds.get_string(tags::patient_id),
        ds.get_string(tags::patient_name),
        ds.get_string(tags::patient_birth_date),
        ds.get_string(tags::patient_sex));
 
    if (patient_result.is_err()) {
        std::cerr << "Database error (patient): "
                  << patient_result.error().message << "\n";
        return false;
    }
    int64_t patient_pk = patient_result.value();
 
    // Study
    auto study_result = index_db_->upsert_study(
        patient_pk,
        ds.get_string(tags::study_instance_uid),
        ds.get_string(tags::study_id),
        ds.get_string(tags::study_date),
        ds.get_string(tags::study_time),
        ds.get_string(tags::accession_number),
        ds.get_string(tags::referring_physician_name),
        ds.get_string(tags::study_description));
 
    if (study_result.is_err()) {
        std::cerr << "Database error (study): "
                  << study_result.error().message << "\n";
        return false;
    }
    int64_t study_pk = study_result.value();
 
    // Series
    auto series_result = index_db_->upsert_series(
        study_pk,
        ds.get_string(tags::series_instance_uid),
        ds.get_string(tags::modality),
        ds.get_numeric<int>(tags::series_number),
        ds.get_string(tags::series_description),
        "",  // body_part_examined
        ds.get_string(tags::station_name));
 
    if (series_result.is_err()) {
        std::cerr << "Database error (series): "
                  << series_result.error().message << "\n";
        return false;
    }
    int64_t series_pk = series_result.value();
 
    // Instance
    auto file_size = std::filesystem::exists(file_path)
        ? static_cast<int64_t>(std::filesystem::file_size(file_path))
        : 0;
 
    auto instance_result = index_db_->upsert_instance(
        series_pk,
        ds.get_string(tags::sop_instance_uid),
        ds.get_string(tags::sop_class_uid),
        file_path.string(),
        file_size,
        ds.get_string(tags::transfer_syntax_uid),
        ds.get_numeric<int>(tags::instance_number));
 
    if (instance_result.is_err()) {
        std::cerr << "Database error (instance): "
                  << instance_result.error().message << "\n";
        return false;
    }
 
    return true;
}

Referenced by handle_store().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wait()

void kcenon::pacs::samples::mini_pacs::wait ( )

Block until server shutdown.

Definition at line 66 of file mini_pacs.cpp.

                     {
    if (server_) {
        server_->wait_for_shutdown();
    }
}

References server_.

Member Data Documentation

◆ config_

mini_pacs_config kcenon::pacs::samples::mini_pacs::config_

private

Definition at line 370 of file mini_pacs.h.

Referenced by config(), configure_server(), handle_mpps_create(), handle_mpps_set(), handle_query(), handle_retrieve(), handle_store(), handle_worklist_query(), initialize_services(), initialize_storage(), resolve_destination(), and setup_event_handlers().

◆ file_storage_

std::shared_ptr<storage::file_storage> kcenon::pacs::samples::mini_pacs::file_storage_

private

Definition at line 374 of file mini_pacs.h.

Referenced by handle_store(), and initialize_storage().

◆ index_db_

std::shared_ptr<storage::index_database> kcenon::pacs::samples::mini_pacs::index_db_

private

Definition at line 375 of file mini_pacs.h.

Referenced by handle_query(), handle_retrieve(), initialize_storage(), and update_index().

◆ mpps_instances_

std::vector<mpps_entry> kcenon::pacs::samples::mini_pacs::mpps_instances_

private

Definition at line 395 of file mini_pacs.h.

Referenced by handle_mpps_create(), and handle_mpps_set().

◆ mpps_mutex_

std::mutex kcenon::pacs::samples::mini_pacs::mpps_mutex_

mutableprivate

Definition at line 394 of file mini_pacs.h.

Referenced by handle_mpps_create(), and handle_mpps_set().

◆ mpps_scp_

std::shared_ptr<services::mpps_scp> kcenon::pacs::samples::mini_pacs::mpps_scp_

private

Definition at line 383 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

◆ query_scp_

std::shared_ptr<services::query_scp> kcenon::pacs::samples::mini_pacs::query_scp_

private

Definition at line 380 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

◆ retrieve_scp_

std::shared_ptr<services::retrieve_scp> kcenon::pacs::samples::mini_pacs::retrieve_scp_

private

Definition at line 381 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

◆ running_

std::atomic<bool> kcenon::pacs::samples::mini_pacs::running_ {false}

private

Definition at line 387 of file mini_pacs.h.

387{false};

Referenced by is_running(), start(), and stop().

◆ server_

std::unique_ptr<network::dicom_server> kcenon::pacs::samples::mini_pacs::server_

private

Definition at line 386 of file mini_pacs.h.

Referenced by configure_server(), setup_event_handlers(), start(), stop(), and wait().

◆ stats_

mini_pacs_statistics kcenon::pacs::samples::mini_pacs::stats_

private

Definition at line 371 of file mini_pacs.h.

Referenced by handle_mpps_create(), handle_mpps_set(), handle_query(), handle_retrieve(), handle_store(), handle_worklist_query(), setup_event_handlers(), and statistics().

◆ storage_scp_

std::shared_ptr<services::storage_scp> kcenon::pacs::samples::mini_pacs::storage_scp_

private

Definition at line 379 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

◆ verification_scp_

std::shared_ptr<services::verification_scp> kcenon::pacs::samples::mini_pacs::verification_scp_

private

Definition at line 378 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

◆ worklist_items_

std::vector<worklist_entry> kcenon::pacs::samples::mini_pacs::worklist_items_

private

Definition at line 391 of file mini_pacs.h.

Referenced by add_worklist_item(), clear_worklist(), get_worklist_items(), and handle_worklist_query().

◆ worklist_mutex_

std::mutex kcenon::pacs::samples::mini_pacs::worklist_mutex_

mutableprivate

Definition at line 390 of file mini_pacs.h.

Referenced by add_worklist_item(), clear_worklist(), get_worklist_items(), and handle_worklist_query().

◆ worklist_scp_

std::shared_ptr<services::worklist_scp> kcenon::pacs::samples::mini_pacs::worklist_scp_

private

Definition at line 382 of file mini_pacs.h.

Referenced by configure_server(), and initialize_services().

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

examples/tutorials/04_mini_pacs/mini_pacs.h
examples/tutorials/04_mini_pacs/mini_pacs.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ mini_pacs() [1/3]

◆ ~mini_pacs()

◆ mini_pacs() [2/3]

◆ mini_pacs() [3/3]

Member Function Documentation

◆ add_worklist_item()

◆ clear_worklist()

◆ config()

◆ configure_server()

◆ create_worklist_response()

◆ get_worklist_items()

◆ handle_mpps_create()

◆ handle_mpps_set()

◆ handle_query()

◆ handle_retrieve()

◆ handle_store()

◆ handle_worklist_query()

◆ initialize_services()

◆ initialize_storage()

◆ is_running()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ resolve_destination()

◆ setup_event_handlers()

◆ start()

◆ statistics()

◆ stop()

◆ update_index()

◆ wait()

Member Data Documentation

◆ config_

◆ file_storage_

◆ index_db_

◆ mpps_instances_

◆ mpps_mutex_

◆ mpps_scp_

◆ query_scp_

◆ retrieve_scp_

◆ running_

◆ server_

◆ stats_

◆ storage_scp_

◆ verification_scp_

◆ worklist_items_

◆ worklist_mutex_

◆ worklist_scp_