kcenon::pacs::web::dicomweb Namespace Reference

Classes
struct	accept_info
	Parsed Accept header information. More...
struct	media_type
	Media types supported by WADO-RS. More...
class	multipart_builder
	Builder for multipart MIME responses. More...
class	multipart_parser
	Parser for multipart/related request bodies. More...
struct	multipart_part
	Parsed part from multipart request. More...
struct	rendered_params
	Parameters for rendered image requests. More...
struct	rendered_result
	Result of rendered image operation. More...
struct	store_instance_result
	STOW-RS store result for a single instance. More...
struct	store_response
	STOW-RS overall store response. More...
struct	validation_result
	Validation result for DICOM instance. More...

Enumerations
enum class	rendered_format { jpeg , png , jphc }
	Rendered image output format. More...

Functions
auto	parse_accept_header (std::string_view accept_header) -> std::vector< accept_info >
	Parse Accept header into structured format.
auto	is_acceptable (const std::vector< accept_info > &accept_infos, std::string_view media_type) -> bool
	Check if a media type is acceptable based on Accept header.
auto	dataset_to_dicom_json (const core::dicom_dataset &dataset, bool include_bulk_data=false, std::string_view bulk_data_uri_prefix="") -> std::string
	Convert a DICOM dataset to DicomJSON format.
auto	vr_to_string (uint16_t vr_code) -> std::string
	Convert a VR type code to DicomJSON VR string.
auto	is_bulk_data_tag (uint32_t tag) -> bool
	Check if a DICOM tag contains bulk data.
auto	validate_instance (const core::dicom_dataset &dataset, std::optional< std::string_view > target_study_uid=std::nullopt) -> validation_result
	Validate a DICOM instance for STOW-RS storage.
auto	build_store_response_json (const store_response &response, std::string_view base_url) -> std::string
	Build STOW-RS response in DicomJSON format.
auto	study_record_to_dicom_json (const storage::study_record &record, std::string_view patient_id, std::string_view patient_name) -> std::string
	Convert a study record to DicomJSON format for QIDO-RS response.
auto	series_record_to_dicom_json (const storage::series_record &record, std::string_view study_uid) -> std::string
	Convert a series record to DicomJSON format for QIDO-RS response.
auto	instance_record_to_dicom_json (const storage::instance_record &record, std::string_view series_uid, std::string_view study_uid) -> std::string
	Convert an instance record to DicomJSON format for QIDO-RS response.
auto	parse_study_query_params (const std::string &url_params) -> storage::study_query
	Parse QIDO-RS query parameters from HTTP request.
auto	parse_series_query_params (const std::string &url_params) -> storage::series_query
	Parse QIDO-RS series query parameters from HTTP request.
auto	parse_instance_query_params (const std::string &url_params) -> storage::instance_query
	Parse QIDO-RS instance query parameters from HTTP request.
auto	parse_frame_numbers (std::string_view frame_list) -> std::vector< uint32_t >
	Parse frame numbers from URL path.
auto	extract_frame (std::span< const uint8_t > pixel_data, uint32_t frame_number, size_t frame_size) -> std::vector< uint8_t >
	Extract a single frame from pixel data.
auto	parse_rendered_params (std::string_view query_string, std::string_view accept_header) -> rendered_params
	Parse rendered image parameters from HTTP request.
auto	apply_window_level (std::span< const uint8_t > pixel_data, uint16_t width, uint16_t height, uint16_t bits_stored, bool is_signed, double window_center, double window_width, double rescale_slope=1.0, double rescale_intercept=0.0) -> std::vector< uint8_t >
	Apply window/level transformation to pixel data.
auto	render_dicom_image (std::string_view file_path, const rendered_params &params) -> rendered_result
	Render a DICOM image to JPEG or PNG.

Enumeration Type Documentation

rendered_format

enum class kcenon::pacs::web::dicomweb::rendered_format

strong

Rendered image output format.

Enumerator
jpeg	JPEG format (default)
png	PNG format.
jphc	HTJ2K format (image/jphc)

Definition at line 456 of file dicomweb_endpoints.h.

                           {
    jpeg,   
    png,    
    jphc    
};

Function Documentation

apply_window_level()

auto kcenon::pacs::web::dicomweb::apply_window_level ( std::span< const uint8_t > pixel_data, uint16_t width, uint16_t height, uint16_t bits_stored, bool is_signed, double window_center, double window_width, double rescale_slope = 1.0, double rescale_intercept = 0.0 ) -> std::vector<uint8_t>

nodiscard

Apply window/level transformation to pixel data.

Parameters

pixel_data	Raw pixel values (16-bit)
width	Image width
height	Image height
bits_stored	Bits stored per pixel
is_signed	Whether pixel values are signed
window_center	Window center value
window_width	Window width value
rescale_slope	Rescale slope (default 1.0)
rescale_intercept	Rescale intercept (default 0.0)

Returns

8-bit grayscale image data

Definition at line 1264 of file dicomweb_endpoints.cpp.

                                                    {
 
    std::vector<uint8_t> output(static_cast<size_t>(width) * height);
 
    // Calculate window boundaries
    double window_min = window_center - window_width / 2.0;
    double window_max = window_center + window_width / 2.0;
 
    size_t pixel_count = static_cast<size_t>(width) * height;
    bool is_16bit = (bits_stored > 8);
 
    for (size_t i = 0; i < pixel_count; ++i) {
        double value;
 
        if (is_16bit) {
            // 16-bit pixel data
            size_t byte_offset = i * 2;
            if (byte_offset + 1 >= pixel_data.size()) break;
 
            if (is_signed) {
                int16_t raw_value = static_cast<int16_t>(
                    pixel_data[byte_offset] |
                    (pixel_data[byte_offset + 1] << 8));
                value = raw_value * rescale_slope + rescale_intercept;
            } else {
                uint16_t raw_value = static_cast<uint16_t>(
                    pixel_data[byte_offset] |
                    (pixel_data[byte_offset + 1] << 8));
                value = raw_value * rescale_slope + rescale_intercept;
            }
        } else {
            // 8-bit pixel data
            if (i >= pixel_data.size()) break;
 
            if (is_signed) {
                value = static_cast<int8_t>(pixel_data[i]) * rescale_slope +
                        rescale_intercept;
            } else {
                value = pixel_data[i] * rescale_slope + rescale_intercept;
            }
        }
 
        // Apply window/level
        uint8_t output_value;
        if (value <= window_min) {
            output_value = 0;
        } else if (value >= window_max) {
            output_value = 255;
        } else {
            output_value = static_cast<uint8_t>(
                (value - window_min) / window_width * 255.0);
        }
 
        output[i] = output_value;
    }
 
    return output;
}

Referenced by render_dicom_image().

Here is the caller graph for this function:

build_store_response_json()

auto kcenon::pacs::web::dicomweb::build_store_response_json ( const store_response & response, std::string_view base_url ) -> std::string

nodiscard

Build STOW-RS response in DicomJSON format.

Parameters

response	The store response
base_url	Base URL for retrieve URLs

Returns

DicomJSON response body

Definition at line 601 of file dicomweb_endpoints.cpp.

                                          {
    std::ostringstream oss;
    oss << "{";
 
    // Referenced SOP Sequence (0008,1199) - successfully stored instances
    if (!response.referenced_instances.empty()) {
        oss << "\"00081199\":{\"vr\":\"SQ\",\"Value\":[";
        bool first = true;
        for (const auto& inst : response.referenced_instances) {
            if (!first) oss << ",";
            first = false;
 
            oss << "{";
            // Referenced SOP Class UID (0008,1150)
            oss << "\"00081150\":{\"vr\":\"UI\",\"Value\":[\""
                << inst.sop_class_uid << "\"]},";
            // Referenced SOP Instance UID (0008,1155)
            oss << "\"00081155\":{\"vr\":\"UI\",\"Value\":[\""
                << inst.sop_instance_uid << "\"]},";
            // Retrieve URL (0008,1190)
            oss << "\"00081190\":{\"vr\":\"UR\",\"Value\":[\""
                << base_url << inst.retrieve_url << "\"]}";
            oss << "}";
        }
        oss << "]}";
    }
 
    // Failed SOP Sequence (0008,1198) - failed instances
    if (!response.failed_instances.empty()) {
        if (!response.referenced_instances.empty()) {
            oss << ",";
        }
        oss << "\"00081198\":{\"vr\":\"SQ\",\"Value\":[";
        bool first = true;
        for (const auto& inst : response.failed_instances) {
            if (!first) oss << ",";
            first = false;
 
            oss << "{";
            // Referenced SOP Class UID (0008,1150)
            if (!inst.sop_class_uid.empty()) {
                oss << "\"00081150\":{\"vr\":\"UI\",\"Value\":[\""
                    << inst.sop_class_uid << "\"]},";
            }
            // Referenced SOP Instance UID (0008,1155)
            if (!inst.sop_instance_uid.empty()) {
                oss << "\"00081155\":{\"vr\":\"UI\",\"Value\":[\""
                    << inst.sop_instance_uid << "\"]},";
            }
            // Failure Reason (0008,1197)
            uint16_t failure_reason = 272; // Processing failure
            if (inst.error_code && *inst.error_code == "DUPLICATE") {
                failure_reason = 273; // Duplicate SOP Instance
            } else if (inst.error_code && *inst.error_code == "INVALID_DATA") {
                failure_reason = 272; // Processing failure
            }
            oss << "\"00081197\":{\"vr\":\"US\",\"Value\":["
                << failure_reason << "]}";
            oss << "}";
        }
        oss << "]}";
    }
 
    oss << "}";
    return oss.str();
}

dataset_to_dicom_json()

auto kcenon::pacs::web::dicomweb::dataset_to_dicom_json ( const core::dicom_dataset & dataset, bool include_bulk_data = false, std::string_view bulk_data_uri_prefix = "" ) -> std::string

nodiscard

Convert a DICOM dataset to DicomJSON format.

Parameters

dataset	The DICOM dataset to convert
include_bulk_data	Whether to include bulk data inline
bulk_data_uri_prefix	URI prefix for bulk data references

Returns

DicomJSON string

Definition at line 670 of file dicomweb_endpoints.cpp.

                                                      {
    std::ostringstream oss;
    oss << "{";
 
    bool first = true;
    // Iterate using begin()/end() - dataset is iterable as map<dicom_tag, dicom_element>
    for (const auto& [tag_key, elem] : dataset) {
        if (!first) {
            oss << ",";
        }
        first = false;
 
        // Format tag as 8-digit hex
        uint32_t tag = tag_key.combined();
        oss << "\"";
        oss << std::hex << std::setfill('0') << std::setw(8) << tag;
        oss << std::dec << "\":{";
 
        // Add VR
        std::string vr_str = vr_enum_to_string(elem.vr());
        oss << "\"vr\":\"" << vr_str << "\"";
 
        // Check if bulk data
        if (is_bulk_data_tag(tag) && !include_bulk_data) {
            if (!bulk_data_uri_prefix.empty()) {
                oss << ",\"BulkDataURI\":\"" << bulk_data_uri_prefix
                    << std::hex << std::setfill('0') << std::setw(8) << tag
                    << std::dec << "\"";
            }
        } else {
            // Add Value based on VR type
            auto value_str = elem.as_string().unwrap_or("");
            if (!value_str.empty()) {
                oss << ",\"Value\":[";
 
                // Handle different VR types
                using vr_type = kcenon::pacs::encoding::vr_type;
                switch (elem.vr()) {
                case vr_type::PN:
                    // Person Name - object with Alphabetic component
                    oss << "{\"Alphabetic\":\"" << json_escape(value_str) << "\"}";
                    break;
 
                case vr_type::IS:
                case vr_type::SL:
                case vr_type::SS:
                case vr_type::UL:
                case vr_type::US:
                    // Integer types - output as number
                    oss << value_str;
                    break;
 
                case vr_type::DS:
                case vr_type::FL:
                case vr_type::FD:
                    // Decimal types - output as number
                    oss << value_str;
                    break;
 
                default:
                    // String types
                    oss << "\"" << json_escape(value_str) << "\"";
                    break;
                }
 
                oss << "]";
            }
        }
 
        oss << "}";
    }
 
    oss << "}";
    return oss.str();
}

References is_bulk_data_tag(), and kcenon::pacs::web::json_escape().

Here is the call graph for this function:

extract_frame()

auto kcenon::pacs::web::dicomweb::extract_frame ( std::span< const uint8_t > pixel_data, uint32_t frame_number, size_t frame_size ) -> std::vector<uint8_t>

nodiscard

Extract a single frame from pixel data.

Parameters

pixel_data	Complete pixel data buffer
frame_number	Frame number to extract (1-based)
frame_size	Size of each frame in bytes

Returns

Frame data, or empty vector if frame doesn't exist

Definition at line 1176 of file dicomweb_endpoints.cpp.

                                             {
 
    if (frame_number == 0 || frame_size == 0) {
        return {};
    }
 
    // Frame numbers are 1-based
    size_t offset = (frame_number - 1) * frame_size;
 
    if (offset + frame_size > pixel_data.size()) {
        return {};  // Frame doesn't exist
    }
 
    return std::vector<uint8_t>(
        pixel_data.begin() + static_cast<ptrdiff_t>(offset),
        pixel_data.begin() + static_cast<ptrdiff_t>(offset + frame_size));
}

Referenced by render_dicom_image().

Here is the caller graph for this function:

instance_record_to_dicom_json()

auto kcenon::pacs::web::dicomweb::instance_record_to_dicom_json ( const storage::instance_record & record, std::string_view series_uid, std::string_view study_uid ) -> std::string

nodiscard

Convert an instance record to DicomJSON format for QIDO-RS response.

Parameters

record	The instance record to convert
series_uid	The Series Instance UID for this instance
study_uid	The Study Instance UID for this instance

Returns

DicomJSON string for the instance

Definition at line 882 of file dicomweb_endpoints.cpp.

                                           {
    std::ostringstream oss;
    oss << "{";
 
    // SOP Class UID (0008,0016)
    if (!record.sop_class_uid.empty()) {
        oss << "\"00080016\":{\"vr\":\"UI\",\"Value\":[\""
            << json_escape(record.sop_class_uid) << "\"]}";
    }
 
    // SOP Instance UID (0008,0018)
    oss << ",\"00080018\":{\"vr\":\"UI\",\"Value\":[\""
        << json_escape(record.sop_uid) << "\"]}";
 
    // Study Instance UID (0020,000D)
    if (!study_uid.empty()) {
        oss << ",\"0020000D\":{\"vr\":\"UI\",\"Value\":[\""
            << json_escape(std::string(study_uid)) << "\"]}";
    }
 
    // Series Instance UID (0020,000E)
    if (!series_uid.empty()) {
        oss << ",\"0020000E\":{\"vr\":\"UI\",\"Value\":[\""
            << json_escape(std::string(series_uid)) << "\"]}";
    }
 
    // Instance Number (0020,0013)
    if (record.instance_number.has_value()) {
        oss << ",\"00200013\":{\"vr\":\"IS\",\"Value\":["
            << *record.instance_number << "]}";
    }
 
    // Rows (0028,0010)
    if (record.rows.has_value()) {
        oss << ",\"00280010\":{\"vr\":\"US\",\"Value\":["
            << *record.rows << "]}";
    }
 
    // Columns (0028,0011)
    if (record.columns.has_value()) {
        oss << ",\"00280011\":{\"vr\":\"US\",\"Value\":["
            << *record.columns << "]}";
    }
 
    // Number of Frames (0028,0008)
    if (record.number_of_frames.has_value()) {
        oss << ",\"00280008\":{\"vr\":\"IS\",\"Value\":["
            << *record.number_of_frames << "]}";
    }
 
    oss << "}";
    return oss.str();
}

References kcenon::pacs::web::json_escape().

Here is the call graph for this function:

is_acceptable()

auto kcenon::pacs::web::dicomweb::is_acceptable ( const std::vector< accept_info > & accept_infos, std::string_view media_type ) -> bool

nodiscard

Check if a media type is acceptable based on Accept header.

Parameters

accept_infos	Parsed accept header
media_type	The media type to check

Returns

true if acceptable

Definition at line 184 of file dicomweb_endpoints.cpp.

                                                      {
    if (accept_infos.empty()) {
        return true; // Accept all if no Accept header
    }
 
    for (const auto& info : accept_infos) {
        if (info.media_type == "*/*" ||
            info.media_type == media_type ||
            (info.media_type.ends_with("/*") &&
             media_type.starts_with(
                 info.media_type.substr(0, info.media_type.size() - 1)))) {
            return true;
        }
    }
    return false;
}

is_bulk_data_tag()

auto kcenon::pacs::web::dicomweb::is_bulk_data_tag ( uint32_t tag ) -> bool

nodiscard

Check if a DICOM tag contains bulk data.

Parameters

tag	The DICOM tag

Returns

true if this is a bulk data tag

Definition at line 295 of file dicomweb_endpoints.cpp.

                                            {
    // Pixel Data and related bulk data tags
    uint16_t group = static_cast<uint16_t>(tag >> 16);
 
    // Audio Sample Data is in group 0x50xx (curve data)
    if (group >= 0x5000 && group <= 0x50FF) {
        uint16_t element = static_cast<uint16_t>(tag & 0xFFFF);
        if (element == 0x3000) {
            return true;  // Audio Sample Data
        }
    }
 
    return tag == 0x7FE00010 ||  // Pixel Data
           tag == 0x7FE00008 ||  // Float Pixel Data
           tag == 0x7FE00009 ||  // Double Float Pixel Data
           tag == 0x00420011 ||  // Encapsulated Document
           tag == 0x00660023 ||  // Triangle Point Index List
           tag == 0x00660024 ||  // Edge Point Index List
           tag == 0x00660025 ||  // Vertex Point Index List
           tag == 0x00660026 ||  // Triangle Strip Sequence
           tag == 0x00660027 ||  // Triangle Fan Sequence
           tag == 0x00660028 ||  // Line Sequence
           tag == 0x00660029;    // Primitive Point Index List
}

Referenced by dataset_to_dicom_json().

Here is the caller graph for this function:

parse_accept_header()

auto kcenon::pacs::web::dicomweb::parse_accept_header ( std::string_view accept_header ) -> std::vector<accept_info>

nodiscard

Parse Accept header into structured format.

Parameters

accept_header

The raw Accept header value

Returns

Vector of parsed accept info, sorted by quality

Definition at line 132 of file dicomweb_endpoints.cpp.

                              {
    std::vector<accept_info> result;
 
    if (accept_header.empty()) {
        // Default to application/dicom
        result.push_back({std::string(media_type::dicom), "", 1.0f});
        return result;
    }
 
    auto parts = split(accept_header, ',');
    for (const auto& part : parts) {
        accept_info info;
        auto params = split(part, ';');
 
        if (params.empty()) {
            continue;
        }
 
        info.media_type = trim(params[0]);
 
        for (size_t i = 1; i < params.size(); ++i) {
            auto param = trim(params[i]);
            if (param.starts_with("q=")) {
                try {
                    info.quality = std::stof(param.substr(2));
                } catch (...) {
                    info.quality = 1.0f;
                }
            } else if (param.starts_with("transfer-syntax=")) {
                info.transfer_syntax = param.substr(16);
                // Remove quotes if present
                if (!info.transfer_syntax.empty() &&
                    info.transfer_syntax.front() == '"') {
                    info.transfer_syntax = info.transfer_syntax.substr(
                        1, info.transfer_syntax.size() - 2);
                }
            }
        }
 
        result.push_back(std::move(info));
    }
 
    // Sort by quality (descending)
    std::sort(result.begin(), result.end(),
              [](const accept_info& a, const accept_info& b) {
                  return a.quality > b.quality;
              });
 
    return result;
}

References kcenon::pacs::web::dicomweb::media_type::dicom.

parse_frame_numbers()

auto kcenon::pacs::web::dicomweb::parse_frame_numbers ( std::string_view frame_list ) -> std::vector<uint32_t>

nodiscard

Parse frame numbers from URL path.

Parameters

frame_list

Comma-separated frame numbers (e.g., "1,3,5" or "1-5")

Returns

Vector of frame numbers (1-based), empty on parse error

Examples

• "1" -> {1}
• "1,3,5" -> {1, 3, 5}
• "1-5" -> {1, 2, 3, 4, 5}
• "1,3-5,7" -> {1, 3, 4, 5, 7}

Definition at line 1121 of file dicomweb_endpoints.cpp.

                                                                           {
    std::vector<uint32_t> frames;
 
    if (frame_list.empty()) {
        return frames;
    }
 
    // Split by comma
    auto parts = split(frame_list, ',');
    for (const auto& part : parts) {
        auto trimmed = trim(part);
        if (trimmed.empty()) {
            continue;
        }
 
        // Check for range (e.g., "1-5")
        auto dash_pos = trimmed.find('-');
        if (dash_pos != std::string::npos && dash_pos > 0 &&
            dash_pos < trimmed.size() - 1) {
            try {
                uint32_t start = std::stoul(trimmed.substr(0, dash_pos));
                uint32_t end = std::stoul(trimmed.substr(dash_pos + 1));
                if (start > 0 && end >= start) {
                    for (uint32_t i = start; i <= end; ++i) {
                        frames.push_back(i);
                    }
                }
            } catch (...) {
                // Invalid range, skip
            }
        } else {
            // Single frame number
            try {
                uint32_t frame = std::stoul(trimmed);
                if (frame > 0) {
                    frames.push_back(frame);
                }
            } catch (...) {
                // Invalid number, skip
            }
        }
    }
 
    // Remove duplicates while preserving order
    std::vector<uint32_t> unique_frames;
    for (auto f : frames) {
        if (std::find(unique_frames.begin(), unique_frames.end(), f) ==
            unique_frames.end()) {
            unique_frames.push_back(f);
        }
    }
 
    return unique_frames;
}

parse_instance_query_params()

auto kcenon::pacs::web::dicomweb::parse_instance_query_params ( const std::string & url_params ) -> storage::instance_query

nodiscard

Parse QIDO-RS instance query parameters from HTTP request.

Parameters

url_params

The URL query parameters

Returns

Instance query parameters

Definition at line 1088 of file dicomweb_endpoints.cpp.

                                                                                       {
    storage::instance_query query;
 
    auto params = parse_query_string(url_params);
    for (const auto& [key, value] : params) {
        if (key == "SeriesInstanceUID" || key == "0020000E") {
            query.series_uid = value;
        } else if (key == "SOPInstanceUID" || key == "00080018") {
            query.sop_uid = value;
        } else if (key == "SOPClassUID" || key == "00080016") {
            query.sop_class_uid = value;
        } else if (key == "InstanceNumber" || key == "00200013") {
            try {
                query.instance_number = std::stoi(value);
            } catch (...) {}
        } else if (key == "limit") {
            try {
                query.limit = std::stoull(value);
            } catch (...) {}
        } else if (key == "offset") {
            try {
                query.offset = std::stoull(value);
            } catch (...) {}
        }
    }
 
    return query;
}

parse_rendered_params()

auto kcenon::pacs::web::dicomweb::parse_rendered_params ( std::string_view query_string, std::string_view accept_header ) -> rendered_params

nodiscard

Parse rendered image parameters from HTTP request.

Parameters

query_string	The URL query string
accept_header	The Accept header value

Returns

Parsed rendered parameters

Definition at line 1201 of file dicomweb_endpoints.cpp.

                                                     {
 
    rendered_params params;
 
    // Determine format from Accept header
    if (accept_header.find("image/jphc") != std::string_view::npos) {
        params.format = rendered_format::jphc;
    } else if (accept_header.find("image/png") != std::string_view::npos) {
        params.format = rendered_format::png;
    } else {
        params.format = rendered_format::jpeg;  // Default to JPEG
    }
 
    // Parse query parameters
    auto query_params = parse_query_string(std::string(query_string));
    for (const auto& [key, value] : query_params) {
        if (key == "quality") {
            try {
                params.quality = std::stoi(value);
                params.quality = std::clamp(params.quality, 1, 100);
            } catch (...) {}
        } else if (key == "windowcenter" || key == "window-center") {
            try {
                params.window_center = std::stod(value);
            } catch (...) {}
        } else if (key == "windowwidth" || key == "window-width") {
            try {
                params.window_width = std::stod(value);
            } catch (...) {}
        } else if (key == "viewport") {
            // Format: WxH or W,H
            auto sep = value.find_first_of("x,");
            if (sep != std::string::npos) {
                try {
                    params.viewport_width =
                        static_cast<uint16_t>(std::stoul(value.substr(0, sep)));
                    params.viewport_height =
                        static_cast<uint16_t>(std::stoul(value.substr(sep + 1)));
                } catch (...) {}
            }
        } else if (key == "rows") {
            try {
                params.viewport_height = static_cast<uint16_t>(std::stoul(value));
            } catch (...) {}
        } else if (key == "columns") {
            try {
                params.viewport_width = static_cast<uint16_t>(std::stoul(value));
            } catch (...) {}
        } else if (key == "frame") {
            try {
                params.frame = std::stoul(value);
                if (params.frame == 0) params.frame = 1;
            } catch (...) {}
        } else if (key == "annotation") {
            params.burn_annotations = (value == "true" || value == "1");
        }
    }
 
    return params;
}

References kcenon::pacs::web::dicomweb::rendered_params::burn_annotations, kcenon::pacs::web::dicomweb::rendered_params::format, kcenon::pacs::web::dicomweb::rendered_params::frame, jpeg, jphc, png, kcenon::pacs::web::dicomweb::rendered_params::quality, kcenon::pacs::web::dicomweb::rendered_params::viewport_height, kcenon::pacs::web::dicomweb::rendered_params::viewport_width, kcenon::pacs::web::dicomweb::rendered_params::window_center, and kcenon::pacs::web::dicomweb::rendered_params::window_width.

parse_series_query_params()

auto kcenon::pacs::web::dicomweb::parse_series_query_params ( const std::string & url_params ) -> storage::series_query

nodiscard

Parse QIDO-RS series query parameters from HTTP request.

Parameters

url_params

The URL query parameters

Returns

Series query parameters

Definition at line 1055 of file dicomweb_endpoints.cpp.

                                                                                   {
    storage::series_query query;
 
    auto params = parse_query_string(url_params);
    for (const auto& [key, value] : params) {
        if (key == "StudyInstanceUID" || key == "0020000D") {
            query.study_uid = value;
        } else if (key == "SeriesInstanceUID" || key == "0020000E") {
            query.series_uid = value;
        } else if (key == "Modality" || key == "00080060") {
            query.modality = value;
        } else if (key == "SeriesNumber" || key == "00200011") {
            try {
                query.series_number = std::stoi(value);
            } catch (...) {}
        } else if (key == "SeriesDescription" || key == "0008103E") {
            query.series_description = value;
        } else if (key == "BodyPartExamined" || key == "00180015") {
            query.body_part_examined = value;
        } else if (key == "limit") {
            try {
                query.limit = std::stoull(value);
            } catch (...) {}
        } else if (key == "offset") {
            try {
                query.offset = std::stoull(value);
            } catch (...) {}
        }
    }
 
    return query;
}

parse_study_query_params()

auto kcenon::pacs::web::dicomweb::parse_study_query_params ( const std::string & url_params ) -> storage::study_query

nodiscard

Parse QIDO-RS query parameters from HTTP request.

Parameters

url_params

The URL query parameters

Returns

Study query parameters

Definition at line 1004 of file dicomweb_endpoints.cpp.

                                                                                 {
    storage::study_query query;
 
    auto params = parse_query_string(url_params);
    for (const auto& [key, value] : params) {
        if (key == "PatientID" || key == "00100020") {
            query.patient_id = value;
        } else if (key == "PatientName" || key == "00100010") {
            query.patient_name = value;
        } else if (key == "StudyInstanceUID" || key == "0020000D") {
            query.study_uid = value;
        } else if (key == "StudyID" || key == "00200010") {
            query.study_id = value;
        } else if (key == "StudyDate" || key == "00080020") {
            // Handle date range (YYYYMMDD-YYYYMMDD)
            auto dash_pos = value.find('-');
            if (dash_pos != std::string::npos && dash_pos > 0 &&
                dash_pos < value.size() - 1) {
                query.study_date_from = value.substr(0, dash_pos);
                query.study_date_to = value.substr(dash_pos + 1);
            } else if (dash_pos == 0) {
                // -YYYYMMDD (up to date)
                query.study_date_to = value.substr(1);
            } else if (dash_pos == value.size() - 1) {
                // YYYYMMDD- (from date)
                query.study_date_from = value.substr(0, dash_pos);
            } else {
                query.study_date = value;
            }
        } else if (key == "AccessionNumber" || key == "00080050") {
            query.accession_number = value;
        } else if (key == "ModalitiesInStudy" || key == "00080061") {
            query.modality = value;
        } else if (key == "ReferringPhysicianName" || key == "00080090") {
            query.referring_physician = value;
        } else if (key == "StudyDescription" || key == "00081030") {
            query.study_description = value;
        } else if (key == "limit") {
            try {
                query.limit = std::stoull(value);
            } catch (...) {}
        } else if (key == "offset") {
            try {
                query.offset = std::stoull(value);
            } catch (...) {}
        }
    }
 
    return query;
}

render_dicom_image()

auto kcenon::pacs::web::dicomweb::render_dicom_image ( std::string_view file_path, const rendered_params & params ) -> rendered_result

nodiscard

Render a DICOM image to JPEG or PNG.

Parameters

file_path	Path to DICOM file
params	Rendering parameters

Returns

Rendered image result

Definition at line 1332 of file dicomweb_endpoints.cpp.

                                                      {
 
    // Load DICOM file
    std::ifstream file(std::string(file_path), std::ios::binary);
    if (!file) {
        return rendered_result::error("Failed to open DICOM file");
    }
 
    std::vector<uint8_t> file_data(
        (std::istreambuf_iterator<char>(file)),
        std::istreambuf_iterator<char>());
    file.close();
 
    auto dicom_result = core::dicom_file::from_bytes(
        std::span<const uint8_t>(file_data.data(), file_data.size()));
 
    if (dicom_result.is_err()) {
        return rendered_result::error("Failed to parse DICOM file");
    }
 
    const auto& dataset = dicom_result.value().dataset();
 
    // Get image parameters
    auto rows_elem = dataset.get(core::tags::rows);
    auto cols_elem = dataset.get(core::tags::columns);
    auto bits_stored_elem = dataset.get(core::tags::bits_stored);
    auto bits_allocated_elem = dataset.get(core::tags::bits_allocated);
    auto pixel_rep_elem = dataset.get(core::tags::pixel_representation);
    auto samples_elem = dataset.get(core::tags::samples_per_pixel);
    auto pixel_data_elem = dataset.get(core::tags::pixel_data);
 
    if (!rows_elem || !cols_elem || !pixel_data_elem) {
        return rendered_result::error("Missing required image attributes");
    }
 
    uint16_t rows = rows_elem->as_numeric<uint16_t>().unwrap_or(0);
    uint16_t cols = cols_elem->as_numeric<uint16_t>().unwrap_or(0);
    uint16_t bits_stored = bits_stored_elem ?
        bits_stored_elem->as_numeric<uint16_t>().unwrap_or(8) : 8;
    uint16_t bits_allocated = bits_allocated_elem ?
        bits_allocated_elem->as_numeric<uint16_t>().unwrap_or(8) : 8;
    uint16_t pixel_rep = pixel_rep_elem ?
        pixel_rep_elem->as_numeric<uint16_t>().unwrap_or(0) : 0;
    uint16_t samples_per_pixel = samples_elem ?
        samples_elem->as_numeric<uint16_t>().unwrap_or(1) : 1;
 
    bool is_signed = (pixel_rep == 1);
 
    // Get window/level from DICOM or use provided parameters
    double window_center = 128.0;
    double window_width = 256.0;
 
    if (params.window_center.has_value()) {
        window_center = *params.window_center;
    } else if (auto wc = dataset.get(core::tags::window_center)) {
        try {
            auto values_result = wc->as_string_list();
            if (values_result.is_ok() && !values_result.value().empty()) {
                window_center = std::stod(values_result.value()[0]);
            }
        } catch (...) {}
    }
 
    if (params.window_width.has_value()) {
        window_width = *params.window_width;
    } else if (auto ww = dataset.get(core::tags::window_width)) {
        try {
            auto values_result = ww->as_string_list();
            if (values_result.is_ok() && !values_result.value().empty()) {
                window_width = std::stod(values_result.value()[0]);
            }
        } catch (...) {}
    }
 
    // Get rescale parameters
    double rescale_slope = 1.0;
    double rescale_intercept = 0.0;
 
    if (auto rs = dataset.get(core::tags::rescale_slope)) {
        try {
            rescale_slope = std::stod(rs->as_string().unwrap_or("1.0"));
        } catch (...) {}
    }
    if (auto ri = dataset.get(core::tags::rescale_intercept)) {
        try {
            rescale_intercept = std::stod(ri->as_string().unwrap_or("0.0"));
        } catch (...) {}
    }
 
    // Get pixel data
    auto pixel_data = pixel_data_elem->raw_data();
 
    // Calculate frame size for multi-frame images
    size_t frame_size = static_cast<size_t>(rows) * cols * samples_per_pixel *
                        ((bits_allocated + 7) / 8);
 
    // Extract specific frame if multi-frame
    std::span<const uint8_t> frame_data = pixel_data;
    if (params.frame > 1) {
        auto extracted = extract_frame(pixel_data, params.frame, frame_size);
        if (extracted.empty()) {
            return rendered_result::error("Requested frame does not exist");
        }
        // For simplicity, we'll just use first frame for now
        // Full implementation would handle multi-frame properly
    }
 
    // Apply window/level for grayscale images
    std::vector<uint8_t> output_pixels;
    if (samples_per_pixel == 1) {
        output_pixels = apply_window_level(
            frame_data, cols, rows, bits_stored, is_signed,
            window_center, window_width, rescale_slope, rescale_intercept);
    } else {
        // For color images, just use raw data (convert to 8-bit if needed)
        output_pixels.resize(static_cast<size_t>(rows) * cols * samples_per_pixel);
        if (bits_allocated == 8) {
            std::copy(frame_data.begin(),
                      frame_data.begin() + (std::min)(frame_data.size(),
                                                     output_pixels.size()),
                      output_pixels.begin());
        } else {
            // Convert 16-bit to 8-bit
            for (size_t i = 0; i < output_pixels.size() && i * 2 + 1 < frame_data.size(); ++i) {
                uint16_t val = static_cast<uint16_t>(
                    frame_data[i * 2] | (frame_data[i * 2 + 1] << 8));
                output_pixels[i] = static_cast<uint8_t>(val >> (bits_stored - 8));
            }
        }
    }
 
    // Encode to requested format
    encoding::compression::image_params img_params;
    img_params.width = cols;
    img_params.height = rows;
    img_params.bits_allocated = 8;
    img_params.bits_stored = 8;
    img_params.high_bit = 7;
    img_params.samples_per_pixel = samples_per_pixel;
    img_params.photometric =
        (samples_per_pixel == 1) ?
        encoding::compression::photometric_interpretation::monochrome2 :
        encoding::compression::photometric_interpretation::rgb;
 
    if (params.format == rendered_format::jphc) {
        encoding::compression::htj2k_codec codec(
            /*lossless=*/false, /*use_rpcl=*/false);
 
        auto result = codec.encode(output_pixels, img_params);
        if (result.is_err()) {
            return rendered_result::error("HTJ2K encoding failed: " +
                                          result.error().message);
        }
 
        return rendered_result::ok(std::move(result.value().data), media_type::jphc);
    } else if (params.format == rendered_format::jpeg) {
        encoding::compression::jpeg_baseline_codec codec;
 
        encoding::compression::compression_options opts;
        opts.quality = params.quality;
 
        auto result = codec.encode(output_pixels, img_params, opts);
        if (result.is_err()) {
            return rendered_result::error("JPEG encoding failed: " +
                                          result.error().message);
        }
 
        return rendered_result::ok(std::move(result.value().data), media_type::jpeg);
    } else {
        // PNG encoding - not implemented yet
        return rendered_result::error("PNG encoding not yet implemented");
    }
}

References apply_window_level(), kcenon::pacs::core::tags::bits_allocated, kcenon::pacs::encoding::compression::image_params::bits_allocated, kcenon::pacs::core::tags::bits_stored, kcenon::pacs::encoding::compression::image_params::bits_stored, kcenon::pacs::core::tags::columns, kcenon::pacs::encoding::compression::htj2k_codec::encode(), kcenon::pacs::encoding::compression::jpeg_baseline_codec::encode(), kcenon::pacs::web::dicomweb::rendered_result::error(), extract_frame(), kcenon::pacs::core::dicom_file::from_bytes(), kcenon::pacs::encoding::compression::image_params::height, kcenon::pacs::encoding::compression::image_params::high_bit, kcenon::pacs::web::dicomweb::media_type::jpeg, jpeg, kcenon::pacs::web::dicomweb::media_type::jphc, jphc, kcenon::pacs::encoding::compression::monochrome2, kcenon::pacs::web::dicomweb::rendered_result::ok(), kcenon::pacs::encoding::compression::image_params::photometric, kcenon::pacs::core::tags::pixel_data, kcenon::pacs::core::tags::pixel_representation, kcenon::pacs::encoding::compression::compression_options::quality, kcenon::pacs::core::tags::rescale_intercept, kcenon::pacs::core::tags::rescale_slope, kcenon::pacs::encoding::compression::rgb, kcenon::pacs::core::tags::rows, kcenon::pacs::core::tags::samples_per_pixel, kcenon::pacs::encoding::compression::image_params::samples_per_pixel, kcenon::pacs::encoding::compression::image_params::width, kcenon::pacs::core::tags::window_center, and kcenon::pacs::core::tags::window_width.

Here is the call graph for this function:

series_record_to_dicom_json()

auto kcenon::pacs::web::dicomweb::series_record_to_dicom_json ( const storage::series_record & record, std::string_view study_uid ) -> std::string

nodiscard

Convert a series record to DicomJSON format for QIDO-RS response.

Parameters

record	The series record to convert
study_uid	The Study Instance UID for this series

Returns

DicomJSON string for the series

Definition at line 835 of file dicomweb_endpoints.cpp.

                                           {
    std::ostringstream oss;
    oss << "{";
 
    // Series Instance UID (0020,000E)
    oss << "\"0020000E\":{\"vr\":\"UI\",\"Value\":[\""
        << json_escape(record.series_uid) << "\"]}";
 
    // Study Instance UID (0020,000D)
    if (!study_uid.empty()) {
        oss << ",\"0020000D\":{\"vr\":\"UI\",\"Value\":[\""
            << json_escape(std::string(study_uid)) << "\"]}";
    }
 
    // Modality (0008,0060)
    if (!record.modality.empty()) {
        oss << ",\"00080060\":{\"vr\":\"CS\",\"Value\":[\""
            << json_escape(record.modality) << "\"]}";
    }
 
    // Series Number (0020,0011)
    if (record.series_number.has_value()) {
        oss << ",\"00200011\":{\"vr\":\"IS\",\"Value\":["
            << *record.series_number << "]}";
    }
 
    // Series Description (0008,103E)
    if (!record.series_description.empty()) {
        oss << ",\"0008103E\":{\"vr\":\"LO\",\"Value\":[\""
            << json_escape(record.series_description) << "\"]}";
    }
 
    // Body Part Examined (0018,0015)
    if (!record.body_part_examined.empty()) {
        oss << ",\"00180015\":{\"vr\":\"CS\",\"Value\":[\""
            << json_escape(record.body_part_examined) << "\"]}";
    }
 
    // Number of Series Related Instances (0020,1209)
    oss << ",\"00201209\":{\"vr\":\"IS\",\"Value\":[" << record.num_instances << "]}";
 
    oss << "}";
    return oss.str();
}

References kcenon::pacs::web::json_escape().

Here is the call graph for this function:

study_record_to_dicom_json()

auto kcenon::pacs::web::dicomweb::study_record_to_dicom_json ( const storage::study_record & record, std::string_view patient_id, std::string_view patient_name ) -> std::string

nodiscard

Convert a study record to DicomJSON format for QIDO-RS response.

Parameters

record	The study record to convert
patient_id	The patient ID for this study
patient_name	The patient name for this study

Returns

DicomJSON string for the study

Definition at line 753 of file dicomweb_endpoints.cpp.

                                              {
    std::ostringstream oss;
    oss << "{";
 
    // Study Instance UID (0020,000D)
    oss << "\"0020000D\":{\"vr\":\"UI\",\"Value\":[\""
        << json_escape(record.study_uid) << "\"]}";
 
    // Study Date (0008,0020)
    if (!record.study_date.empty()) {
        oss << ",\"00080020\":{\"vr\":\"DA\",\"Value\":[\""
            << json_escape(record.study_date) << "\"]}";
    }
 
    // Study Time (0008,0030)
    if (!record.study_time.empty()) {
        oss << ",\"00080030\":{\"vr\":\"TM\",\"Value\":[\""
            << json_escape(record.study_time) << "\"]}";
    }
 
    // Accession Number (0008,0050)
    if (!record.accession_number.empty()) {
        oss << ",\"00080050\":{\"vr\":\"SH\",\"Value\":[\""
            << json_escape(record.accession_number) << "\"]}";
    }
 
    // Modalities in Study (0008,0061)
    if (!record.modalities_in_study.empty()) {
        oss << ",\"00080061\":{\"vr\":\"CS\",\"Value\":[";
        auto modalities = split(record.modalities_in_study, '\\');
        bool first = true;
        for (const auto& mod : modalities) {
            if (!first) oss << ",";
            first = false;
            oss << "\"" << json_escape(mod) << "\"";
        }
        oss << "]}";
    }
 
    // Referring Physician's Name (0008,0090)
    if (!record.referring_physician.empty()) {
        oss << ",\"00080090\":{\"vr\":\"PN\",\"Value\":[{\"Alphabetic\":\""
            << json_escape(record.referring_physician) << "\"}]}";
    }
 
    // Patient's Name (0010,0010)
    if (!patient_name.empty()) {
        oss << ",\"00100010\":{\"vr\":\"PN\",\"Value\":[{\"Alphabetic\":\""
            << json_escape(std::string(patient_name)) << "\"}]}";
    }
 
    // Patient ID (0010,0020)
    if (!patient_id.empty()) {
        oss << ",\"00100020\":{\"vr\":\"LO\",\"Value\":[\""
            << json_escape(std::string(patient_id)) << "\"]}";
    }
 
    // Study ID (0020,0010)
    if (!record.study_id.empty()) {
        oss << ",\"00200010\":{\"vr\":\"SH\",\"Value\":[\""
            << json_escape(record.study_id) << "\"]}";
    }
 
    // Study Description (0008,1030)
    if (!record.study_description.empty()) {
        oss << ",\"00081030\":{\"vr\":\"LO\",\"Value\":[\""
            << json_escape(record.study_description) << "\"]}";
    }
 
    // Number of Study Related Series (0020,1206)
    oss << ",\"00201206\":{\"vr\":\"IS\",\"Value\":[" << record.num_series << "]}";
 
    // Number of Study Related Instances (0020,1208)
    oss << ",\"00201208\":{\"vr\":\"IS\",\"Value\":[" << record.num_instances << "]}";
 
    oss << "}";
    return oss.str();
}

References kcenon::pacs::web::json_escape().

Here is the call graph for this function:

validate_instance()

auto kcenon::pacs::web::dicomweb::validate_instance ( const core::dicom_dataset & dataset, std::optional< std::string_view > target_study_uid = std::nullopt ) -> validation_result

nodiscard

Validate a DICOM instance for STOW-RS storage.

Parameters

dataset	The DICOM dataset to validate
target_study_uid	Optional target study UID (for existing study)

Returns

Validation result

Definition at line 551 of file dicomweb_endpoints.cpp.

                                                                       {
 
    // Check required DICOM tags
    auto sop_class = dataset.get(core::tags::sop_class_uid);
    if (!sop_class || sop_class->as_string().unwrap_or("").empty()) {
        return validation_result::error(
            "MISSING_SOP_CLASS",
            "SOP Class UID (0008,0016) is required");
    }
 
    auto sop_instance = dataset.get(core::tags::sop_instance_uid);
    if (!sop_instance || sop_instance->as_string().unwrap_or("").empty()) {
        return validation_result::error(
            "MISSING_SOP_INSTANCE",
            "SOP Instance UID (0008,0018) is required");
    }
 
    auto study_uid = dataset.get(core::tags::study_instance_uid);
    if (!study_uid || study_uid->as_string().unwrap_or("").empty()) {
        return validation_result::error(
            "MISSING_STUDY_UID",
            "Study Instance UID (0020,000D) is required");
    }
 
    auto series_uid = dataset.get(core::tags::series_instance_uid);
    if (!series_uid || series_uid->as_string().unwrap_or("").empty()) {
        return validation_result::error(
            "MISSING_SERIES_UID",
            "Series Instance UID (0020,000E) is required");
    }
 
    // Validate study UID matches target if specified
    if (target_study_uid.has_value()) {
        auto instance_study_uid = study_uid->as_string().unwrap_or("");
        if (instance_study_uid != *target_study_uid) {
            return validation_result::error(
                "STUDY_UID_MISMATCH",
                "Instance Study UID does not match target study");
        }
    }
 
    return validation_result::ok();
}

References kcenon::pacs::web::dicomweb::validation_result::error(), kcenon::pacs::web::dicomweb::validation_result::ok(), kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_class_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Here is the call graph for this function:

vr_to_string()

auto kcenon::pacs::web::dicomweb::vr_to_string ( uint16_t vr_code ) -> std::string

nodiscard

Convert a VR type code to DicomJSON VR string.

Parameters

vr_code

The VR type code

Returns

VR string (e.g., "PN", "LO", "UI")

Definition at line 320 of file dicomweb_endpoints.cpp.

                                                 {
    // Convert 2-byte VR code to string
    char vr[3] = {static_cast<char>(vr_code & 0xFF),
                  static_cast<char>((vr_code >> 8) & 0xFF),
                  '\0'};
    return std::string(vr);
}

References vr.