kcenon::pacs::services::print_scp Class Reference

Print Management SCP service. More...

#include <print_scp.h>

Inheritance diagram for kcenon::pacs::services::print_scp:

Collaboration diagram for kcenon::pacs::services::print_scp:

Public Member Functions
	print_scp (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct Print SCP with optional logger.
	~print_scp () override=default
void	set_session_handler (print_session_handler handler)
	Set handler for film session creation.
void	set_print_handler (print_action_handler handler)
	Set handler for print action (film box print)
void	set_printer_status_handler (printer_status_handler handler)
	Set handler for printer status query.
std::vector< std::string >	supported_sop_classes () const override
	Get supported SOP Class UIDs.
network::Result< std::monostate >	handle_message (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request) override
	Handle an incoming DIMSE-N message.
std::string_view	service_name () const noexcept override
	Get the service name.
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
Public Member Functions inherited from kcenon::pacs::services::scp_service
	scp_service (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct SCP service with optional logger.
virtual	~scp_service ()=default
	scp_service (const scp_service &)=delete
scp_service &	operator= (const scp_service &)=delete
	scp_service (scp_service &&)=default
scp_service &	operator= (scp_service &&)=default
void	set_logger (std::shared_ptr< di::ILogger > logger)
	Set the logger instance.
const std::shared_ptr< di::ILogger > &	logger () const noexcept
	Get the current logger instance.
bool	supports_sop_class (std::string_view sop_class_uid) const
	Check if this service supports a specific SOP Class.

Private Member Functions
network::Result< std::monostate >	handle_n_create (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_set (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_get (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_action (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_delete (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	create_film_session (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	create_film_box (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	send_response (network::association &assoc, uint8_t context_id, network::dimse::command_field response_type, uint16_t message_id, std::string_view sop_class_uid, const std::string &sop_instance_uid, network::dimse::status_code status)
auto	generate_uid () -> std::string

Private Attributes
print_session_handler	session_handler_
print_action_handler	print_handler_
printer_status_handler	printer_status_handler_
std::unordered_map< std::string, film_session >	sessions_
	Active film sessions indexed by SOP Instance UID.
std::unordered_map< std::string, film_box >	film_boxes_
	Active film boxes indexed by SOP Instance UID.
std::unordered_map< std::string, image_box >	image_boxes_
	Active image boxes indexed by SOP Instance UID.
std::mutex	mutex_
	Mutex for state management.
std::atomic< uint32_t >	uid_counter_ {0}
	UID generation 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}

Additional Inherited Members
Protected Attributes inherited from kcenon::pacs::services::scp_service
std::shared_ptr< di::ILogger >	logger_
	Logger instance for service logging.

Detailed Description

Print Management SCP service.

Handles DICOM print requests for Film Session, Film Box, Image Box, and Printer SOP Classes.

Print Workflow

SCU (Workstation)                         SCP (Print Server)
 |                                        |
 |  N-CREATE Film Session                 |
 |--------------------------------------->|
 |                                        |
 |  N-CREATE Film Box                     |
 |--------------------------------------->|
 |                                        |
 |  N-SET Image Box (pixel data)          |
 |--------------------------------------->|
 |                                        |
 |  N-ACTION Film Box (Print)             |
 |--------------------------------------->|
 |                                        |
 |  N-DELETE Film Session                 |
 |--------------------------------------->|

Definition at line 239 of file print_scp.h.

Constructor & Destructor Documentation

print_scp()

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

explicit

Construct Print SCP with optional logger.

Parameters

logger

Logger instance for service logging

Definition at line 27 of file print_scp.cpp.

    : scp_service(std::move(logger)) {}

~print_scp()

kcenon::pacs::services::print_scp::~print_scp ( )

overridedefault

Member Function Documentation

create_film_box()

network::Result< std::monostate > kcenon::pacs::services::print_scp::create_film_box ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 580 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_instance_uid = request.affected_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        sop_instance_uid = generate_uid();
    }
 
    film_box box;
    box.sop_instance_uid = sop_instance_uid;
 
    if (request.has_dataset()) {
        const auto& ds = request.dataset().value().get();
        box.data = ds;
 
        if (ds.contains(print_tags::image_display_format)) {
            box.image_display_format = ds.get_string(print_tags::image_display_format);
        }
        if (ds.contains(print_tags::film_orientation)) {
            box.film_orientation = ds.get_string(print_tags::film_orientation);
        }
        if (ds.contains(print_tags::film_size_id)) {
            box.film_size_id = ds.get_string(print_tags::film_size_id);
        }
    }
 
    // Parse image display format to determine image box count
    // Format: "STANDARD\C,R" where C=columns, R=rows
    uint16_t num_image_boxes = 1;
    auto format = box.image_display_format;
    auto backslash_pos = format.find('\\');
    if (backslash_pos != std::string::npos) {
        auto dims = format.substr(backslash_pos + 1);
        auto comma_pos = dims.find(',');
        if (comma_pos != std::string::npos) {
            auto cols = static_cast<uint16_t>(
                std::stoul(dims.substr(0, comma_pos)));
            auto rows = static_cast<uint16_t>(
                std::stoul(dims.substr(comma_pos + 1)));
            num_image_boxes = static_cast<uint16_t>(cols * rows);
        }
    }
 
    // Create image boxes for this film box
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Link to parent film session if found
    for (auto& [_, session] : sessions_) {
        session.film_box_uids.push_back(sop_instance_uid);
        box.film_session_uid = session.sop_instance_uid;
        break;  // Link to first (most recent) session
    }
 
    for (uint16_t i = 1; i <= num_image_boxes; ++i) {
        image_box ib;
        ib.sop_instance_uid = generate_uid();
        ib.film_box_uid = sop_instance_uid;
        ib.image_position = i;
        box.image_box_uids.push_back(ib.sop_instance_uid);
        image_boxes_.emplace(ib.sop_instance_uid, std::move(ib));
    }
 
    film_boxes_.emplace(sop_instance_uid, std::move(box));
    ++film_boxes_created_;
 
    // Build response with Referenced Image Box Sequence
    dimse_message response{command_field::n_create_rsp, 0};
    response.set_message_id_responded_to(request.message_id());
    response.set_affected_sop_class_uid(basic_film_box_sop_class_uid);
    response.set_affected_sop_instance_uid(sop_instance_uid);
    response.set_status(status_success);
 
    // Add referenced image box UIDs in response dataset
    using namespace encoding;
    core::dicom_dataset response_ds;
    auto& fb = film_boxes_.at(sop_instance_uid);
    auto& seq = response_ds.get_or_create_sequence(
        print_tags::referenced_image_box_sequence);
    for (size_t i = 0; i < fb.image_box_uids.size(); ++i) {
        core::dicom_dataset ref_item;
        ref_item.set_string(core::tags::referenced_sop_class_uid, vr_type::UI,
                           std::string(basic_grayscale_image_box_sop_class_uid));
        ref_item.set_string(core::tags::referenced_sop_instance_uid, vr_type::UI,
                           fb.image_box_uids[i]);
        seq.push_back(std::move(ref_item));
    }
    response.set_dataset(std::move(response_ds));
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_grayscale_image_box_sop_class_uid, kcenon::pacs::services::film_box::data, kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::services::image_box::film_box_uid, film_boxes_, film_boxes_created_, kcenon::pacs::services::film_box::film_orientation, kcenon::pacs::services::print_tags::film_orientation, kcenon::pacs::services::film_box::film_session_uid, kcenon::pacs::services::film_box::film_size_id, kcenon::pacs::services::print_tags::film_size_id, generate_uid(), kcenon::pacs::core::dicom_dataset::get_or_create_sequence(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), kcenon::pacs::services::film_box::image_box_uids, image_boxes_, kcenon::pacs::services::film_box::image_display_format, kcenon::pacs::services::print_tags::image_display_format, kcenon::pacs::services::image_box::image_position, kcenon::pacs::network::dimse::dimse_message::message_id(), mutex_, kcenon::pacs::services::print_tags::referenced_image_box_sequence, kcenon::pacs::core::tags::referenced_sop_class_uid, kcenon::pacs::core::tags::referenced_sop_instance_uid, kcenon::pacs::network::association::send_dimse(), sessions_, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::services::film_box::sop_instance_uid, and kcenon::pacs::services::image_box::sop_instance_uid.

Referenced by handle_n_create().

Here is the call graph for this function:

Here is the caller graph for this function:

create_film_session()

network::Result< std::monostate > kcenon::pacs::services::print_scp::create_film_session ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 515 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_instance_uid = request.affected_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        sop_instance_uid = generate_uid();
    }
 
    film_session session;
    session.sop_instance_uid = sop_instance_uid;
 
    if (request.has_dataset()) {
        const auto& ds = request.dataset().value().get();
        session.data = ds;
 
        if (ds.contains(print_tags::number_of_copies)) {
            auto copies_str = ds.get_string(print_tags::number_of_copies);
            if (!copies_str.empty()) {
                session.number_of_copies =
                    static_cast<uint32_t>(std::stoul(copies_str));
            }
        }
        if (ds.contains(print_tags::print_priority)) {
            session.print_priority = ds.get_string(print_tags::print_priority);
        }
        if (ds.contains(print_tags::medium_type)) {
            session.medium_type = ds.get_string(print_tags::medium_type);
        }
        if (ds.contains(print_tags::film_destination)) {
            session.film_destination = ds.get_string(print_tags::film_destination);
        }
    }
 
    // Call session handler
    if (session_handler_) {
        auto result = session_handler_(session);
        if (result.is_err()) {
            return send_response(
                assoc, context_id, command_field::n_create_rsp,
                request.message_id(), basic_film_session_sop_class_uid,
                sop_instance_uid, status_error_unable_to_process);
        }
    }
 
    {
        std::lock_guard<std::mutex> lock(mutex_);
        sessions_.emplace(sop_instance_uid, std::move(session));
    }
 
    ++sessions_created_;
 
    return send_response(
        assoc, context_id, command_field::n_create_rsp,
        request.message_id(), basic_film_session_sop_class_uid,
        sop_instance_uid, status_success);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::services::basic_film_session_sop_class_uid, kcenon::pacs::services::film_session::data, kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::services::film_session::film_destination, kcenon::pacs::services::print_tags::film_destination, generate_uid(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), kcenon::pacs::services::film_session::medium_type, kcenon::pacs::services::print_tags::medium_type, kcenon::pacs::network::dimse::dimse_message::message_id(), mutex_, kcenon::pacs::services::film_session::number_of_copies, kcenon::pacs::services::print_tags::number_of_copies, kcenon::pacs::services::film_session::print_priority, kcenon::pacs::services::print_tags::print_priority, send_response(), session_handler_, sessions_, sessions_created_, and kcenon::pacs::services::film_session::sop_instance_uid.

Referenced by handle_n_create().

Here is the call graph for this function:

Here is the caller graph for this function:

film_boxes_created()

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

nodiscardnoexcept

Definition at line 100 of file print_scp.cpp.

                                                    {
    return film_boxes_created_.load();
}

References film_boxes_created_.

generate_uid()

auto kcenon::pacs::services::print_scp::generate_uid ( ) -> std::string

nodiscardprivate

Definition at line 706 of file print_scp.cpp.

                                          {
    auto counter = uid_counter_.fetch_add(1);
    auto now = std::chrono::steady_clock::now().time_since_epoch();
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now).count();
 
    std::ostringstream oss;
    oss << "2.25." << ms << "." << counter;
    return oss.str();
}

Referenced by create_film_box(), and create_film_session().

Here is the caller graph for this function:

handle_message()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_message ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardoverridevirtual

Handle an incoming DIMSE-N message.

Routes N-CREATE, N-SET, N-GET, N-ACTION, N-DELETE to appropriate handlers based on the affected SOP class.

Implements kcenon::pacs::services::scp_service.

Definition at line 62 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    switch (request.command()) {
        case command_field::n_create_rq:
            return handle_n_create(assoc, context_id, request);
        case command_field::n_set_rq:
            return handle_n_set(assoc, context_id, request);
        case command_field::n_get_rq:
            return handle_n_get(assoc, context_id, request);
        case command_field::n_action_rq:
            return handle_n_action(assoc, context_id, request);
        case command_field::n_delete_rq:
            return handle_n_delete(assoc, context_id, request);
        default:
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::print_unexpected_command,
                "Unexpected command for Print SCP: " +
                std::string(to_string(request.command())));
    }
}

References kcenon::pacs::network::dimse::dimse_message::command(), handle_n_action(), handle_n_create(), handle_n_delete(), handle_n_get(), handle_n_set(), kcenon::pacs::pacs_void_error(), kcenon::pacs::error_codes::print_unexpected_command, and kcenon::pacs::services::to_string().

Here is the call graph for this function:

handle_n_action()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_n_action ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 356 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_class_uid = request.affected_sop_class_uid();
 
    // N-ACTION is used on Film Session or Film Box to initiate printing
    if (sop_class_uid != basic_film_session_sop_class_uid &&
        sop_class_uid != basic_film_box_sop_class_uid) {
        return send_response(
            assoc, context_id, command_field::n_action_rsp,
            request.message_id(), sop_class_uid,
            "", status_refused_sop_class_not_supported);
    }
 
    auto sop_instance_uid = request.affected_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        return send_response(
            assoc, context_id, command_field::n_action_rsp,
            request.message_id(), sop_class_uid,
            "", status_error_missing_attribute);
    }
 
    // Verify the object exists
    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (sop_class_uid == basic_film_box_sop_class_uid) {
            if (film_boxes_.find(sop_instance_uid) == film_boxes_.end()) {
                return send_response(
                    assoc, context_id, command_field::n_action_rsp,
                    request.message_id(), sop_class_uid,
                    sop_instance_uid, status_error_invalid_object_instance);
            }
        } else {
            if (sessions_.find(sop_instance_uid) == sessions_.end()) {
                return send_response(
                    assoc, context_id, command_field::n_action_rsp,
                    request.message_id(), sop_class_uid,
                    sop_instance_uid, status_error_invalid_object_instance);
            }
        }
    }
 
    // Call print handler
    if (print_handler_) {
        auto result = print_handler_(sop_instance_uid);
        if (result.is_err()) {
            return send_response(
                assoc, context_id, command_field::n_action_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_unable_to_process);
        }
    }
 
    ++prints_executed_;
 
    // Build action response with action type ID
    dimse_message response{command_field::n_action_rsp, 0};
    response.set_message_id_responded_to(request.message_id());
    response.set_affected_sop_class_uid(sop_class_uid);
    response.set_affected_sop_instance_uid(sop_instance_uid);
    response.set_status(status_success);
 
    auto action_type = request.action_type_id();
    if (action_type.has_value()) {
        response.set_action_type_id(action_type.value());
    }
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::dimse::dimse_message::action_type_id(), kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_film_session_sop_class_uid, film_boxes_, kcenon::pacs::network::dimse::dimse_message::message_id(), mutex_, print_handler_, prints_executed_, kcenon::pacs::network::association::send_dimse(), send_response(), and sessions_.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_create()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_n_create ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 128 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_class_uid = request.affected_sop_class_uid();
 
    if (sop_class_uid == basic_film_session_sop_class_uid) {
        return create_film_session(assoc, context_id, request);
    }
    if (sop_class_uid == basic_film_box_sop_class_uid) {
        return create_film_box(assoc, context_id, request);
    }
 
    return send_response(
        assoc, context_id, command_field::n_create_rsp,
        request.message_id(), sop_class_uid,
        "", status_refused_sop_class_not_supported);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_film_session_sop_class_uid, create_film_box(), create_film_session(), kcenon::pacs::network::dimse::dimse_message::message_id(), and send_response().

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_delete()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_n_delete ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 435 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_class_uid = request.affected_sop_class_uid();
    auto sop_instance_uid = request.affected_sop_instance_uid();
 
    if (sop_instance_uid.empty()) {
        return send_response(
            assoc, context_id, command_field::n_delete_rsp,
            request.message_id(), sop_class_uid,
            "", status_error_missing_attribute);
    }
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (sop_class_uid == basic_film_session_sop_class_uid) {
        auto it = sessions_.find(sop_instance_uid);
        if (it == sessions_.end()) {
            return send_response(
                assoc, context_id, command_field::n_delete_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_invalid_object_instance);
        }
 
        // Delete associated film boxes and their image boxes
        for (const auto& fb_uid : it->second.film_box_uids) {
            auto fb_it = film_boxes_.find(fb_uid);
            if (fb_it != film_boxes_.end()) {
                for (const auto& ib_uid : fb_it->second.image_box_uids) {
                    image_boxes_.erase(ib_uid);
                }
                film_boxes_.erase(fb_it);
            }
        }
        sessions_.erase(it);
 
    } else if (sop_class_uid == basic_film_box_sop_class_uid) {
        auto it = film_boxes_.find(sop_instance_uid);
        if (it == film_boxes_.end()) {
            return send_response(
                assoc, context_id, command_field::n_delete_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_invalid_object_instance);
        }
 
        // Delete associated image boxes
        for (const auto& ib_uid : it->second.image_box_uids) {
            image_boxes_.erase(ib_uid);
        }
 
        // Remove from parent session's film box list
        for (auto& [_, session] : sessions_) {
            auto& fb_uids = session.film_box_uids;
            fb_uids.erase(
                std::remove(fb_uids.begin(), fb_uids.end(), sop_instance_uid),
                fb_uids.end());
        }
        film_boxes_.erase(it);
 
    } else {
        return send_response(
            assoc, context_id, command_field::n_delete_rsp,
            request.message_id(), sop_class_uid,
            sop_instance_uid, status_refused_sop_class_not_supported);
    }
 
    return send_response(
        assoc, context_id, command_field::n_delete_rsp,
        request.message_id(), sop_class_uid,
        sop_instance_uid, status_success);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_film_session_sop_class_uid, film_boxes_, image_boxes_, kcenon::pacs::network::dimse::dimse_message::message_id(), mutex_, send_response(), and sessions_.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_get()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_n_get ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 288 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_class_uid = request.affected_sop_class_uid();
    if (sop_class_uid.empty()) {
        sop_class_uid = request.command_set().get_string(
            tag_requested_sop_class_uid);
    }
 
    if (sop_class_uid != printer_sop_class_uid) {
        return send_response(
            assoc, context_id, command_field::n_get_rsp,
            request.message_id(), sop_class_uid,
            "", status_refused_sop_class_not_supported);
    }
 
    ++printer_queries_;
 
    // Build printer status response
    core::dicom_dataset response_ds;
 
    using namespace encoding;
 
    if (printer_status_handler_) {
        auto result = printer_status_handler_();
        if (result.is_ok()) {
            auto& [status, info_ds] = result.value();
            response_ds = std::move(info_ds);
            response_ds.set_string(print_tags::printer_status_tag, vr_type::CS,
                                   std::string(to_string(status)));
        } else {
            response_ds.set_string(print_tags::printer_status_tag, vr_type::CS, "NORMAL");
            response_ds.set_string(print_tags::printer_status_info, vr_type::ST, "");
        }
    } else {
        // Default: report printer as normal
        response_ds.set_string(print_tags::printer_status_tag, vr_type::CS, "NORMAL");
        response_ds.set_string(print_tags::printer_status_info, vr_type::ST, "");
        response_ds.set_string(print_tags::printer_name, vr_type::LO, "PACS_PRINTER");
    }
 
    // Build response message
    dimse_message response{command_field::n_get_rsp, 0};
    response.set_message_id_responded_to(request.message_id());
    response.set_affected_sop_class_uid(printer_sop_class_uid);
    response.set_status(status_success);
 
    auto sop_instance_uid = request.command_set().get_string(
        tag_requested_sop_instance_uid);
    if (sop_instance_uid.empty()) {
        sop_instance_uid = request.affected_sop_instance_uid();
    }
    if (!sop_instance_uid.empty()) {
        response.set_affected_sop_instance_uid(sop_instance_uid);
    }
 
    response.set_dataset(std::move(response_ds));
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::network::dimse::dimse_message::command_set(), kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::services::print_tags::printer_name, printer_queries_, kcenon::pacs::services::printer_sop_class_uid, printer_status_handler_, kcenon::pacs::services::print_tags::printer_status_info, kcenon::pacs::services::print_tags::printer_status_tag, kcenon::pacs::network::association::send_dimse(), send_response(), kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::to_string().

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_set()

network::Result< std::monostate > kcenon::pacs::services::print_scp::handle_n_set ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 154 of file print_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    auto sop_class_uid = request.affected_sop_class_uid();
    if (sop_class_uid.empty()) {
        sop_class_uid = request.command_set().get_string(
            tag_requested_sop_class_uid);
    }
 
    auto sop_instance_uid = request.command_set().get_string(
        tag_requested_sop_instance_uid);
    if (sop_instance_uid.empty()) {
        sop_instance_uid = request.affected_sop_instance_uid();
    }
 
    if (sop_instance_uid.empty()) {
        return send_response(
            assoc, context_id, command_field::n_set_rsp,
            request.message_id(), sop_class_uid,
            "", status_error_missing_attribute);
    }
 
    // Handle Image Box N-SET (grayscale or color)
    if (sop_class_uid == basic_grayscale_image_box_sop_class_uid ||
        sop_class_uid == basic_color_image_box_sop_class_uid) {
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = image_boxes_.find(sop_instance_uid);
        if (it == image_boxes_.end()) {
            return send_response(
                assoc, context_id, command_field::n_set_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_invalid_object_instance);
        }
 
        if (request.has_dataset()) {
            it->second.data = request.dataset().value().get();
            it->second.has_pixel_data = true;
        }
 
        ++images_set_;
 
        return send_response(
            assoc, context_id, command_field::n_set_rsp,
            request.message_id(), sop_class_uid,
            sop_instance_uid, status_success);
    }
 
    // Handle Film Session N-SET
    if (sop_class_uid == basic_film_session_sop_class_uid) {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = sessions_.find(sop_instance_uid);
        if (it == sessions_.end()) {
            return send_response(
                assoc, context_id, command_field::n_set_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_invalid_object_instance);
        }
 
        if (request.has_dataset()) {
            const auto& ds = request.dataset().value().get();
            it->second.data = ds;
 
            if (ds.contains(print_tags::number_of_copies)) {
                auto copies_str = ds.get_string(print_tags::number_of_copies);
                if (!copies_str.empty()) {
                    it->second.number_of_copies =
                        static_cast<uint32_t>(std::stoul(copies_str));
                }
            }
            if (ds.contains(print_tags::print_priority)) {
                it->second.print_priority = ds.get_string(print_tags::print_priority);
            }
            if (ds.contains(print_tags::medium_type)) {
                it->second.medium_type = ds.get_string(print_tags::medium_type);
            }
        }
 
        return send_response(
            assoc, context_id, command_field::n_set_rsp,
            request.message_id(), sop_class_uid,
            sop_instance_uid, status_success);
    }
 
    // Handle Film Box N-SET
    if (sop_class_uid == basic_film_box_sop_class_uid) {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = film_boxes_.find(sop_instance_uid);
        if (it == film_boxes_.end()) {
            return send_response(
                assoc, context_id, command_field::n_set_rsp,
                request.message_id(), sop_class_uid,
                sop_instance_uid, status_error_invalid_object_instance);
        }
 
        if (request.has_dataset()) {
            const auto& ds = request.dataset().value().get();
            it->second.data = ds;
 
            if (ds.contains(print_tags::image_display_format)) {
                it->second.image_display_format =
                    ds.get_string(print_tags::image_display_format);
            }
            if (ds.contains(print_tags::film_orientation)) {
                it->second.film_orientation = ds.get_string(print_tags::film_orientation);
            }
            if (ds.contains(print_tags::film_size_id)) {
                it->second.film_size_id = ds.get_string(print_tags::film_size_id);
            }
        }
 
        return send_response(
            assoc, context_id, command_field::n_set_rsp,
            request.message_id(), sop_class_uid,
            sop_instance_uid, status_success);
    }
 
    return send_response(
        assoc, context_id, command_field::n_set_rsp,
        request.message_id(), sop_class_uid,
        sop_instance_uid, status_refused_sop_class_not_supported);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::services::basic_color_image_box_sop_class_uid, kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_film_session_sop_class_uid, kcenon::pacs::services::basic_grayscale_image_box_sop_class_uid, kcenon::pacs::network::dimse::dimse_message::command_set(), kcenon::pacs::network::dimse::dimse_message::dataset(), film_boxes_, kcenon::pacs::services::print_tags::film_orientation, kcenon::pacs::services::print_tags::film_size_id, kcenon::pacs::network::dimse::dimse_message::has_dataset(), image_boxes_, kcenon::pacs::services::print_tags::image_display_format, images_set_, kcenon::pacs::services::print_tags::medium_type, kcenon::pacs::network::dimse::dimse_message::message_id(), mutex_, kcenon::pacs::services::print_tags::number_of_copies, kcenon::pacs::services::print_tags::print_priority, send_response(), and sessions_.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

images_set()

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

nodiscardnoexcept

Definition at line 104 of file print_scp.cpp.

                                            {
    return images_set_.load();
}

References images_set_.

printer_queries()

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

nodiscardnoexcept

Definition at line 112 of file print_scp.cpp.

                                                 {
    return printer_queries_.load();
}

References printer_queries_.

prints_executed()

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

nodiscardnoexcept

Definition at line 108 of file print_scp.cpp.

                                                 {
    return prints_executed_.load();
}

References prints_executed_.

reset_statistics()

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

noexcept

Definition at line 116 of file print_scp.cpp.

                                          {
    sessions_created_ = 0;
    film_boxes_created_ = 0;
    images_set_ = 0;
    prints_executed_ = 0;
    printer_queries_ = 0;
}

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

send_response()

network::Result< std::monostate > kcenon::pacs::services::print_scp::send_response ( network::association & assoc, uint8_t context_id, network::dimse::command_field response_type, uint16_t message_id, std::string_view sop_class_uid, const std::string & sop_instance_uid, network::dimse::status_code status )

nodiscardprivate

Definition at line 679 of file print_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    dimse_message response{response_type, 0};
    response.set_message_id_responded_to(message_id);
    response.set_affected_sop_class_uid(sop_class_uid);
    response.set_status(status);
 
    if (!sop_instance_uid.empty()) {
        response.set_affected_sop_instance_uid(sop_instance_uid);
    }
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse().

Referenced by create_film_session(), handle_n_action(), handle_n_create(), handle_n_delete(), handle_n_get(), and handle_n_set().

Here is the call graph for this function:

Here is the caller graph for this function:

service_name()

std::string_view kcenon::pacs::services::print_scp::service_name ( ) const

nodiscardoverridevirtualnoexcept

Get the service name.

Returns

"Print SCP"

Implements kcenon::pacs::services::scp_service.

Definition at line 88 of file print_scp.cpp.

                                                      {
    return "Print SCP";
}

sessions_created()

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

nodiscardnoexcept

Definition at line 96 of file print_scp.cpp.

                                                  {
    return sessions_created_.load();
}

References sessions_created_.

set_print_handler()

void kcenon::pacs::services::print_scp::set_print_handler

(

print_action_handler

handler

)

Set handler for print action (film box print)

Definition at line 38 of file print_scp.cpp.

                                                              {
    print_handler_ = std::move(handler);
}

References print_handler_.

set_printer_status_handler()

void kcenon::pacs::services::print_scp::set_printer_status_handler

(

printer_status_handler

handler

)

Set handler for printer status query.

Definition at line 42 of file print_scp.cpp.

                                                                         {
    printer_status_handler_ = std::move(handler);
}

References printer_status_handler_.

set_session_handler()

void kcenon::pacs::services::print_scp::set_session_handler

(

print_session_handler

handler

)

Set handler for film session creation.

Definition at line 34 of file print_scp.cpp.

                                                                 {
    session_handler_ = std::move(handler);
}

References session_handler_.

supported_sop_classes()

std::vector< std::string > kcenon::pacs::services::print_scp::supported_sop_classes ( ) const

nodiscardoverridevirtual

Get supported SOP Class UIDs.

Returns

Vector of Print Management SOP Class UIDs

Implements kcenon::pacs::services::scp_service.

Definition at line 50 of file print_scp.cpp.

                                                            {
    return {
        std::string(basic_film_session_sop_class_uid),
        std::string(basic_film_box_sop_class_uid),
        std::string(basic_grayscale_image_box_sop_class_uid),
        std::string(basic_color_image_box_sop_class_uid),
        std::string(printer_sop_class_uid),
        std::string(basic_grayscale_print_meta_sop_class_uid),
        std::string(basic_color_print_meta_sop_class_uid),
    };
}

References kcenon::pacs::services::basic_color_image_box_sop_class_uid, kcenon::pacs::services::basic_color_print_meta_sop_class_uid, kcenon::pacs::services::basic_film_box_sop_class_uid, kcenon::pacs::services::basic_film_session_sop_class_uid, kcenon::pacs::services::basic_grayscale_image_box_sop_class_uid, kcenon::pacs::services::basic_grayscale_print_meta_sop_class_uid, and kcenon::pacs::services::printer_sop_class_uid.

Member Data Documentation

film_boxes_

std::unordered_map<std::string, film_box> kcenon::pacs::services::print_scp::film_boxes_

private

Active film boxes indexed by SOP Instance UID.

Definition at line 388 of file print_scp.h.

Referenced by create_film_box(), handle_n_action(), handle_n_delete(), and handle_n_set().

film_boxes_created_

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

private

Definition at line 401 of file print_scp.h.

{0};

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

image_boxes_

std::unordered_map<std::string, image_box> kcenon::pacs::services::print_scp::image_boxes_

private

Active image boxes indexed by SOP Instance UID.

Definition at line 391 of file print_scp.h.

Referenced by create_film_box(), handle_n_delete(), and handle_n_set().

images_set_

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

private

Definition at line 402 of file print_scp.h.

{0};

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

mutex_

std::mutex kcenon::pacs::services::print_scp::mutex_

mutableprivate

Mutex for state management.

Definition at line 394 of file print_scp.h.

Referenced by create_film_box(), create_film_session(), handle_n_action(), handle_n_delete(), and handle_n_set().

print_handler_

print_action_handler kcenon::pacs::services::print_scp::print_handler_

private

Definition at line 381 of file print_scp.h.

Referenced by handle_n_action(), and set_print_handler().

printer_queries_

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

private

Definition at line 404 of file print_scp.h.

{0};

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

printer_status_handler_

printer_status_handler kcenon::pacs::services::print_scp::printer_status_handler_

private

Definition at line 382 of file print_scp.h.

Referenced by handle_n_get(), and set_printer_status_handler().

prints_executed_

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

private

Definition at line 403 of file print_scp.h.

{0};

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

session_handler_

print_session_handler kcenon::pacs::services::print_scp::session_handler_

private

Definition at line 380 of file print_scp.h.

Referenced by create_film_session(), and set_session_handler().

sessions_

std::unordered_map<std::string, film_session> kcenon::pacs::services::print_scp::sessions_

private

Active film sessions indexed by SOP Instance UID.

Definition at line 385 of file print_scp.h.

Referenced by create_film_box(), create_film_session(), handle_n_action(), handle_n_delete(), and handle_n_set().

sessions_created_

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

private

Statistics.

Definition at line 400 of file print_scp.h.

{0};

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

uid_counter_

std::atomic<uint32_t> kcenon::pacs::services::print_scp::uid_counter_ {0}

private

UID generation counter.

Definition at line 397 of file print_scp.h.

{0};

---

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

• include/kcenon/pacs/services/print_scp.h
• src/services/print_scp.cpp