#include <print_scu.h>

Collaboration diagram for kcenon::pacs::services::print_scu:

Public Member Functions
	print_scu (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct Print SCU with default configuration.

	print_scu (const print_scu_config &config, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct Print SCU with custom configuration.

	~print_scu ()=default

	print_scu (const print_scu &)=delete

print_scu &	operator= (const print_scu &)=delete

	print_scu (print_scu &&)=delete

print_scu &	operator= (print_scu &&)=delete

network::Result< print_result >	create_film_session (network::association &assoc, const print_session_data &data)
	Create a new Film Session (N-CREATE)

network::Result< print_result >	delete_film_session (network::association &assoc, std::string_view session_uid)
	Delete a Film Session (N-DELETE)

network::Result< print_result >	create_film_box (network::association &assoc, const print_film_box_data &data)
	Create a new Film Box (N-CREATE)

network::Result< print_result >	print_film_box (network::association &assoc, std::string_view film_box_uid)
	Print a Film Box (N-ACTION)

network::Result< print_result >	delete_film_box (network::association &assoc, std::string_view film_box_uid)
	Delete a Film Box (N-DELETE)

network::Result< print_result >	set_image_box (network::association &assoc, std::string_view image_box_uid, const print_image_data &data, bool use_color=false)
	Set Image Box pixel data (N-SET)

network::Result< print_result >	query_printer_status (network::association &assoc)
	Query printer status (N-GET)

size_t	sessions_created () const noexcept

size_t	film_boxes_created () const noexcept

size_t	images_set () const noexcept

size_t	prints_executed () const noexcept

size_t	printer_queries () const noexcept

void	reset_statistics () noexcept

Private Member Functions
std::optional< uint8_t >	find_print_context (network::association &assoc, std::string_view sop_class_uid) const
	Find an accepted presentation context for a print SOP class.

std::string	generate_uid () const
	Generate a unique SOP Instance UID.

uint16_t	next_message_id () noexcept
	Get the next message ID for DIMSE operations.

Private Attributes
std::shared_ptr< di::ILogger >	logger_
	Logger instance.

print_scu_config	config_
	Configuration.

std::atomic< uint16_t >	message_id_counter_ {1}
	Message ID counter.

std::atomic< size_t >	sessions_created_ {0}
	Statistics.

std::atomic< size_t >	film_boxes_created_ {0}

std::atomic< size_t >	images_set_ {0}

std::atomic< size_t >	prints_executed_ {0}

std::atomic< size_t >	printer_queries_ {0}

Detailed Description

Examples: print_scu/main.cpp.

Definition at line 231 of file print_scu.h.

Constructor & Destructor Documentation

◆ print_scu() [1/4]

kcenon::pacs::services::print_scu::print_scu ( std::shared_ptr< di::ILogger > logger = nullptr )

explicit

Construct Print SCU with default configuration.

Parameters

logger Logger instance for service logging (nullptr uses null_logger)

Definition at line 143 of file print_scu.cpp.

144 : logger_(logger ? std::move(logger) : di::null_logger()) {}

kcenon::pacs::services::print_scu::logger_

std::shared_ptr< di::ILogger > logger_

Logger instance.

Definition print_scu.h:409

kcenon::pacs::di::null_logger

std::shared_ptr< ILogger > null_logger()

Get a shared null logger instance.

Definition ilogger.h:271

◆ print_scu() [2/4]

kcenon::pacs::services::print_scu::print_scu	(	const print_scu_config &	config,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct Print SCU with custom configuration.

Parameters

config	Configuration options
logger	Logger instance for service logging (nullptr uses null_logger)

Definition at line 146 of file print_scu.cpp.

148 : logger_(logger ? std::move(logger) : di::null_logger()),

149 config_(config) {}

kcenon::pacs::services::print_scu::config_

print_scu_config config_

Configuration.

Definition print_scu.h:412

◆ ~print_scu()

kcenon::pacs::services::print_scu::~print_scu ( )

default

◆ print_scu() [3/4]

kcenon::pacs::services::print_scu::print_scu ( const print_scu & )

delete

◆ print_scu() [4/4]

kcenon::pacs::services::print_scu::print_scu ( print_scu && )

delete

Member Function Documentation

◆ create_film_box()

network::Result< print_result > kcenon::pacs::services::print_scu::create_film_box	(	network::association &	assoc,
		const print_film_box_data &	data )

nodiscard

Create a new Film Box (N-CREATE)

The SCP will auto-create Image Boxes based on the image display format. Referenced Image Box UIDs are returned in the response dataset.

Parameters

assoc	The established association to use
data	Film box creation data

Returns: Result containing print_result (response_data has image box UIDs)

Examples: print_scu/main.cpp.

Definition at line 330 of file print_scu.cpp.

                                     {
 
    using namespace network::dimse;
    using namespace encoding;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, basic_film_box_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Film Box SOP Class");
    }
 
    // Build creation dataset
    core::dicom_dataset ds;
    if (!data.image_display_format.empty()) {
        ds.set_string(print_tags::image_display_format, vr_type::ST,
                      data.image_display_format);
    }
    if (!data.film_orientation.empty()) {
        ds.set_string(print_tags::film_orientation, vr_type::CS, data.film_orientation);
    }
    if (!data.film_size_id.empty()) {
        ds.set_string(print_tags::film_size_id, vr_type::CS, data.film_size_id);
    }
    if (!data.magnification_type.empty()) {
        ds.set_string(print_tags::magnification_type, vr_type::CS,
                      data.magnification_type);
    }
 
    // Add referenced film session sequence
    if (!data.film_session_uid.empty()) {
        auto& seq = ds.get_or_create_sequence(
            print_tags::referenced_film_session_sequence);
        core::dicom_dataset ref_item;
        ref_item.set_string(core::tags::referenced_sop_class_uid, vr_type::UI,
                           std::string(basic_film_session_sop_class_uid));
        ref_item.set_string(core::tags::referenced_sop_instance_uid, vr_type::UI,
                           data.film_session_uid);
        seq.push_back(std::move(ref_item));
    }
 
    auto request = make_n_create_rq(
        next_message_id(),
        basic_film_box_sop_class_uid,
        "",  // SCP generates the UID
        std::move(ds));
 
    logger_->debug("Sending N-CREATE Film Box");
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-CREATE Film Box: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-CREATE Film Box response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_create_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-CREATE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(response.affected_sop_instance_uid());
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    // Capture response dataset (contains Referenced Image Box Sequence)
    if (response.has_dataset()) {
        result.response_data = response.dataset().value().get();
    }
 
    film_boxes_created_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-CREATE Film Box successful: " + result.sop_instance_uid);
    } else {
        logger_->warn("N-CREATE Film Box status 0x" +
                      std::to_string(result.status));
    }
 
    return result;
}

Here is the call graph for this function:

◆ create_film_session()

network::Result< print_result > kcenon::pacs::services::print_scu::create_film_session	(	network::association &	assoc,
		const print_session_data &	data )

nodiscard

Create a new Film Session (N-CREATE)

Parameters

assoc	The established association to use
data	Film session creation data

Returns: Result containing print_result on success

Examples: print_scu/main.cpp.

Definition at line 155 of file print_scu.cpp.

                                    {
 
    using namespace network::dimse;
    using namespace encoding;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, basic_film_session_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Film Session SOP Class");
    }
 
    std::string session_uid = data.sop_instance_uid;
    if (session_uid.empty() && config_.auto_generate_uid) {
        session_uid = generate_uid();
    }
 
    // Build creation dataset
    core::dicom_dataset ds;
    ds.set_string(print_tags::number_of_copies, vr_type::IS,
                  std::to_string(data.number_of_copies));
    if (!data.print_priority.empty()) {
        ds.set_string(print_tags::print_priority, vr_type::CS, data.print_priority);
    }
    if (!data.medium_type.empty()) {
        ds.set_string(print_tags::medium_type, vr_type::CS, data.medium_type);
    }
    if (!data.film_destination.empty()) {
        ds.set_string(print_tags::film_destination, vr_type::CS, data.film_destination);
    }
    if (!data.film_session_label.empty()) {
        ds.set_string(print_tags::film_session_label, vr_type::LO, data.film_session_label);
    }
 
    auto request = make_n_create_rq(
        next_message_id(),
        basic_film_session_sop_class_uid,
        session_uid,
        std::move(ds));
 
    logger_->debug("Sending N-CREATE Film Session: " + session_uid);
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-CREATE Film Session: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-CREATE Film Session response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_create_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-CREATE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = response.affected_sop_instance_uid().empty()
        ? session_uid : std::string(response.affected_sop_instance_uid());
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    sessions_created_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-CREATE Film Session successful: " + result.sop_instance_uid);
    } else {
        logger_->warn("N-CREATE Film Session status 0x" +
                      std::to_string(result.status) + ": " + result.sop_instance_uid);
    }
 
    return result;
}

Here is the call graph for this function:

◆ delete_film_box()

network::Result< print_result > kcenon::pacs::services::print_scu::delete_film_box	(	network::association &	assoc,
		std::string_view	film_box_uid )

nodiscard

Delete a Film Box (N-DELETE)

Parameters

assoc	The established association to use
film_box_uid	Film Box SOP Instance UID

Returns: Result containing print_result on success

Definition at line 516 of file print_scu.cpp.

                                 {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, basic_film_box_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Film Box SOP Class");
    }
 
    auto request = make_n_delete_rq(
        next_message_id(),
        basic_film_box_sop_class_uid,
        film_box_uid);
 
    logger_->debug("Sending N-DELETE Film Box: " + std::string(film_box_uid));
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-DELETE Film Box: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-DELETE Film Box response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_delete_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-DELETE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(film_box_uid);
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    if (result.is_success()) {
        logger_->info("N-DELETE Film Box successful: " + std::string(film_box_uid));
    } else {
        logger_->warn("N-DELETE Film Box status 0x" +
                      std::to_string(result.status) + ": " + std::string(film_box_uid));
    }
 
    return result;
}

References kcenon::pacs::error_codes::association_not_established, kcenon::pacs::services::basic_film_box_sop_class_uid, config_, kcenon::pacs::services::print_result::elapsed, kcenon::pacs::services::print_result::error_comment, find_print_context(), kcenon::pacs::network::association::is_established(), kcenon::pacs::services::print_result::is_success(), logger_, next_message_id(), kcenon::pacs::pacs_error(), kcenon::pacs::error_codes::print_invalid_sop_class, kcenon::pacs::error_codes::print_unexpected_command, kcenon::pacs::network::association::receive_dimse(), kcenon::pacs::network::association::send_dimse(), kcenon::pacs::services::print_result::sop_instance_uid, kcenon::pacs::services::print_result::status, kcenon::pacs::services::print_scu_config::timeout, and kcenon::pacs::services::to_string().

Here is the call graph for this function:

◆ delete_film_session()

network::Result< print_result > kcenon::pacs::services::print_scu::delete_film_session	(	network::association &	assoc,
		std::string_view	session_uid )

nodiscard

Delete a Film Session (N-DELETE)

Also deletes all associated Film Boxes and Image Boxes on the SCP side.

Parameters

assoc	The established association to use
session_uid	Film Session SOP Instance UID

Returns: Result containing print_result on success

Examples: print_scu/main.cpp.

Definition at line 254 of file print_scu.cpp.

                                {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, basic_film_session_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Film Session SOP Class");
    }
 
    auto request = make_n_delete_rq(
        next_message_id(),
        basic_film_session_sop_class_uid,
        session_uid);
 
    logger_->debug("Sending N-DELETE Film Session: " + std::string(session_uid));
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-DELETE Film Session: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-DELETE Film Session response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_delete_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-DELETE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(session_uid);
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    if (result.is_success()) {
        logger_->info("N-DELETE Film Session successful: " + std::string(session_uid));
    } else {
        logger_->warn("N-DELETE Film Session status 0x" +
                      std::to_string(result.status) + ": " + std::string(session_uid));
    }
 
    return result;
}

References kcenon::pacs::error_codes::association_not_established, kcenon::pacs::services::basic_film_session_sop_class_uid, config_, kcenon::pacs::services::print_result::elapsed, kcenon::pacs::services::print_result::error_comment, find_print_context(), kcenon::pacs::network::association::is_established(), kcenon::pacs::services::print_result::is_success(), logger_, next_message_id(), kcenon::pacs::pacs_error(), kcenon::pacs::error_codes::print_invalid_sop_class, kcenon::pacs::error_codes::print_unexpected_command, kcenon::pacs::network::association::receive_dimse(), kcenon::pacs::network::association::send_dimse(), kcenon::pacs::services::print_result::sop_instance_uid, kcenon::pacs::services::print_result::status, kcenon::pacs::services::print_scu_config::timeout, and kcenon::pacs::services::to_string().

Here is the call graph for this function:

◆ film_boxes_created()

size_t kcenon::pacs::services::print_scu::film_boxes_created ( ) const

nodiscardnoexcept

Definition at line 775 of file print_scu.cpp.

                                                    {
    return film_boxes_created_.load(std::memory_order_relaxed);
}

References film_boxes_created_.

◆ find_print_context()

std::optional< uint8_t > kcenon::pacs::services::print_scu::find_print_context	(	network::association &	assoc,
		std::string_view	sop_class_uid ) const

nodiscardprivate

Find an accepted presentation context for a print SOP class.

Tries the specific SOP class first, then falls back to Meta SOP classes.

Definition at line 803 of file print_scu.cpp.

                                        {
 
    // Try the specific SOP class first
    auto context = assoc.accepted_context_id(sop_class_uid);
    if (context) {
        return context;
    }
 
    // Fall back to Meta SOP Classes which bundle multiple print SOP classes
    context = assoc.accepted_context_id(basic_grayscale_print_meta_sop_class_uid);
    if (context) {
        return context;
    }
 
    context = assoc.accepted_context_id(basic_color_print_meta_sop_class_uid);
    return context;
}

References kcenon::pacs::network::association::accepted_context_id(), kcenon::pacs::services::basic_color_print_meta_sop_class_uid, and kcenon::pacs::services::basic_grayscale_print_meta_sop_class_uid.

Referenced by create_film_box(), create_film_session(), delete_film_box(), delete_film_session(), print_film_box(), query_printer_status(), and set_image_box().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_uid()

std::string kcenon::pacs::services::print_scu::generate_uid ( ) const

nodiscardprivate

Generate a unique SOP Instance UID.

Definition at line 823 of file print_scu.cpp.

                                        {
    static std::mt19937_64 gen{std::random_device{}()};
    static std::uniform_int_distribution<uint64_t> dist;
 
    auto now = std::chrono::system_clock::now();
    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count();
 
    return std::string(uid_root) + "." + std::to_string(timestamp) +
           "." + std::to_string(dist(gen) % 100000);
}

Referenced by create_film_session().

Here is the caller graph for this function:

◆ images_set()

size_t kcenon::pacs::services::print_scu::images_set ( ) const

nodiscardnoexcept

Definition at line 779 of file print_scu.cpp.

                                            {
    return images_set_.load(std::memory_order_relaxed);
}

References images_set_.

◆ next_message_id()

uint16_t kcenon::pacs::services::print_scu::next_message_id ( )

nodiscardprivatenoexcept

Get the next message ID for DIMSE operations.

Definition at line 835 of file print_scu.cpp.

                                             {
    uint16_t id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    if (id == 0) {
        id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    }
    return id;
}

References message_id_counter_.

Referenced by create_film_box(), create_film_session(), delete_film_box(), delete_film_session(), print_film_box(), query_printer_status(), and set_image_box().

Here is the caller graph for this function:

◆ operator=() [1/2]

print_scu & kcenon::pacs::services::print_scu::operator= ( const print_scu & )

delete

◆ operator=() [2/2]

print_scu & kcenon::pacs::services::print_scu::operator= ( print_scu && )

delete

◆ print_film_box()

network::Result< print_result > kcenon::pacs::services::print_scu::print_film_box	(	network::association &	assoc,
		std::string_view	film_box_uid )

nodiscard

Print a Film Box (N-ACTION)

Sends N-ACTION to the SCP to initiate printing of the film box.

Parameters

assoc	The established association to use
film_box_uid	Film Box SOP Instance UID

Returns: Result containing print_result on success

Examples: print_scu/main.cpp.

Definition at line 440 of file print_scu.cpp.

                                 {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, basic_film_box_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Film Box SOP Class");
    }
 
    // Action Type ID 1 = Print
    auto request = make_n_action_rq(
        next_message_id(),
        basic_film_box_sop_class_uid,
        film_box_uid,
        1);
 
    logger_->debug("Sending N-ACTION Print Film Box: " + std::string(film_box_uid));
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-ACTION Print: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-ACTION Print response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_action_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-ACTION-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(film_box_uid);
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    prints_executed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-ACTION Print successful: " + std::string(film_box_uid));
    } else {
        logger_->warn("N-ACTION Print status 0x" +
                      std::to_string(result.status) + ": " + std::string(film_box_uid));
    }
 
    return result;
}

Here is the call graph for this function:

◆ printer_queries()

size_t kcenon::pacs::services::print_scu::printer_queries ( ) const

nodiscardnoexcept

Definition at line 787 of file print_scu.cpp.

                                                 {
    return printer_queries_.load(std::memory_order_relaxed);
}

References printer_queries_.

◆ prints_executed()

size_t kcenon::pacs::services::print_scu::prints_executed ( ) const

nodiscardnoexcept

Definition at line 783 of file print_scu.cpp.

                                                 {
    return prints_executed_.load(std::memory_order_relaxed);
}

References prints_executed_.

◆ query_printer_status()

network::Result< print_result > kcenon::pacs::services::print_scu::query_printer_status ( network::association & assoc )

nodiscard

Query printer status (N-GET)

Sends N-GET to the Printer SOP Class to retrieve printer status. The response_data in print_result contains the printer status dataset.

Parameters

assoc The established association to use

Returns: Result containing print_result with printer status in response_data

Examples: print_scu/main.cpp.

Definition at line 686 of file print_scu.cpp.

                               {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto context_id = find_print_context(assoc, printer_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Printer SOP Class");
    }
 
    // Well-Known Printer SOP Instance UID (PS3.4 H.4.17)
    constexpr std::string_view printer_instance_uid =
        "1.2.840.10008.5.1.1.17";
 
    auto request = make_n_get_rq(
        next_message_id(),
        printer_sop_class_uid,
        printer_instance_uid);
 
    logger_->debug("Sending N-GET Printer Status");
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-GET Printer Status: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-GET Printer Status response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_get_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-GET-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(printer_instance_uid);
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    if (response.has_dataset()) {
        result.response_data = response.dataset().value().get();
    }
 
    printer_queries_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-GET Printer Status successful");
    } else {
        logger_->warn("N-GET Printer Status returned 0x" +
                      std::to_string(result.status));
    }
 
    return result;
}

Here is the call graph for this function:

◆ reset_statistics()

void kcenon::pacs::services::print_scu::reset_statistics ( )

noexcept

Definition at line 791 of file print_scu.cpp.

                                          {
    sessions_created_.store(0, std::memory_order_relaxed);
    film_boxes_created_.store(0, std::memory_order_relaxed);
    images_set_.store(0, std::memory_order_relaxed);
    prints_executed_.store(0, std::memory_order_relaxed);
    printer_queries_.store(0, std::memory_order_relaxed);
}

References film_boxes_created_, images_set_, printer_queries_, prints_executed_, and sessions_created_.

◆ sessions_created()

size_t kcenon::pacs::services::print_scu::sessions_created ( ) const

nodiscardnoexcept

Definition at line 771 of file print_scu.cpp.

                                                  {
    return sessions_created_.load(std::memory_order_relaxed);
}

References sessions_created_.

◆ set_image_box()

network::Result< print_result > kcenon::pacs::services::print_scu::set_image_box	(	network::association &	assoc,
		std::string_view	image_box_uid,
		const print_image_data &	data,
		bool	use_color = false )

nodiscard

Set Image Box pixel data (N-SET)

Sets the pixel data for an Image Box in the film box. Use Basic Grayscale Image Box SOP Class by default.

Parameters

assoc	The established association to use
image_box_uid	Image Box SOP Instance UID
data	Image data to set
use_color	Use Basic Color Image Box instead of Grayscale

Returns: Result containing print_result on success

Definition at line 592 of file print_scu.cpp.

                    {
 
    using namespace network::dimse;
    using namespace encoding;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    auto sop_class_uid = use_color
        ? basic_color_image_box_sop_class_uid
        : basic_grayscale_image_box_sop_class_uid;
 
    auto context_id = find_print_context(assoc, sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_invalid_sop_class,
            "No accepted presentation context for Image Box SOP Class");
    }
 
    // Build modification dataset with pixel data in the appropriate sequence
    core::dicom_dataset ds = data.pixel_data;
 
    if (data.image_position > 0) {
        ds.set_string(print_tags::image_position, vr_type::US,
                      std::to_string(data.image_position));
    }
 
    auto request = make_n_set_rq(
        next_message_id(),
        sop_class_uid,
        image_box_uid,
        std::move(ds));
 
    logger_->debug("Sending N-SET Image Box: " + std::string(image_box_uid));
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-SET Image Box: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-SET Image Box response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_set_rsp) {
        return kcenon::pacs::pacs_error<print_result>(
            kcenon::pacs::error_codes::print_unexpected_command,
            "Expected N-SET-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
 
    print_result result;
    result.sop_instance_uid = std::string(image_box_uid);
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    images_set_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-SET Image Box successful: " + std::string(image_box_uid));
    } else {
        logger_->warn("N-SET Image Box status 0x" +
                      std::to_string(result.status) + ": " + std::string(image_box_uid));
    }
 
    return result;
}

Here is the call graph for this function:

Member Data Documentation

◆ config_

print_scu_config kcenon::pacs::services::print_scu::config_

private

Configuration.

Definition at line 412 of file print_scu.h.

Referenced by create_film_box(), create_film_session(), delete_film_box(), delete_film_session(), print_film_box(), query_printer_status(), and set_image_box().

◆ film_boxes_created_

std::atomic<size_t> kcenon::pacs::services::print_scu::film_boxes_created_ {0}

private

Definition at line 419 of file print_scu.h.

419{0};

Referenced by create_film_box(), film_boxes_created(), and reset_statistics().

◆ images_set_

std::atomic<size_t> kcenon::pacs::services::print_scu::images_set_ {0}

private

Definition at line 420 of file print_scu.h.

420{0};

Referenced by images_set(), reset_statistics(), and set_image_box().

◆ logger_

std::shared_ptr<di::ILogger> kcenon::pacs::services::print_scu::logger_

private

Logger instance.

Definition at line 409 of file print_scu.h.

Referenced by create_film_box(), create_film_session(), delete_film_box(), delete_film_session(), print_film_box(), query_printer_status(), and set_image_box().

◆ message_id_counter_

std::atomic<uint16_t> kcenon::pacs::services::print_scu::message_id_counter_ {1}

private

Message ID counter.

Definition at line 415 of file print_scu.h.

415{1};

Referenced by next_message_id().

◆ printer_queries_

std::atomic<size_t> kcenon::pacs::services::print_scu::printer_queries_ {0}

private

Definition at line 422 of file print_scu.h.

422{0};

Referenced by printer_queries(), query_printer_status(), and reset_statistics().

◆ prints_executed_

std::atomic<size_t> kcenon::pacs::services::print_scu::prints_executed_ {0}

private

Definition at line 421 of file print_scu.h.

421{0};

Referenced by print_film_box(), prints_executed(), and reset_statistics().

◆ sessions_created_

std::atomic<size_t> kcenon::pacs::services::print_scu::sessions_created_ {0}

private

Statistics.

Definition at line 418 of file print_scu.h.

418{0};

Referenced by create_film_session(), reset_statistics(), and sessions_created().

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

include/kcenon/pacs/services/print_scu.h
src/services/print_scu.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ print_scu() [1/4]

◆ print_scu() [2/4]

◆ ~print_scu()

◆ print_scu() [3/4]

◆ print_scu() [4/4]

Member Function Documentation

◆ create_film_box()

◆ create_film_session()

◆ delete_film_box()

◆ delete_film_session()

◆ film_boxes_created()

◆ find_print_context()

◆ generate_uid()

◆ images_set()

◆ next_message_id()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print_film_box()

◆ printer_queries()

◆ prints_executed()

◆ query_printer_status()

◆ reset_statistics()

◆ sessions_created()

◆ set_image_box()

Member Data Documentation

◆ config_

◆ film_boxes_created_

◆ images_set_

◆ logger_

◆ message_id_counter_

◆ printer_queries_

◆ prints_executed_

◆ sessions_created_