Factory class for creating compression codec instances. More...

#include <codec_factory.h>

Collaboration diagram for kcenon::pacs::encoding::compression::codec_factory:

Static Public Member Functions
static std::unique_ptr< compression_codec >	create (std::string_view transfer_syntax_uid)
	Creates a codec instance for the given Transfer Syntax UID.

static std::unique_ptr< compression_codec >	create (const transfer_syntax &ts)
	Creates a codec instance for the given Transfer Syntax.

static std::vector< std::string_view >	supported_transfer_syntaxes ()
	Returns a list of all supported Transfer Syntax UIDs.

static bool	is_supported (std::string_view transfer_syntax_uid)
	Checks if a Transfer Syntax is supported for compression.

static bool	is_supported (const transfer_syntax &ts)
	Checks if a Transfer Syntax is supported for compression.

Private Member Functions
	codec_factory ()=delete

Detailed Description

Factory class for creating compression codec instances.

Provides a centralized registry for codec creation based on Transfer Syntax UID. Thread-safe: All factory methods can be called from multiple threads.

Usage:

auto codec = codec_factory::create("1.2.840.10008.1.2.4.50");
if (codec) {
    auto result = codec->encode(pixel_data, params);
}

Definition at line 38 of file codec_factory.h.

Constructor & Destructor Documentation

◆ codec_factory()

kcenon::pacs::encoding::compression::codec_factory::codec_factory ( )

privatedelete

Member Function Documentation

◆ create() [1/2]

std::unique_ptr< compression_codec > kcenon::pacs::encoding::compression::codec_factory::create ( const transfer_syntax & ts )

staticnodiscard

Creates a codec instance for the given Transfer Syntax.

Parameters

ts	The Transfer Syntax object

Returns: A codec instance if supported, nullptr otherwise

Definition at line 135 of file codec_factory.cpp.

                               {
    return create(ts.uid());
}

References create().

Here is the call graph for this function:

◆ create() [2/2]

std::unique_ptr< compression_codec > kcenon::pacs::encoding::compression::codec_factory::create ( std::string_view transfer_syntax_uid )

staticnodiscard

Creates a codec instance for the given Transfer Syntax UID.

Parameters

transfer_syntax_uid The DICOM Transfer Syntax UID

Returns: A codec instance if supported, nullptr otherwise

Supported UIDs:

1.2.840.10008.1.2.4.50 - JPEG Baseline (Process 1)

Definition at line 49 of file codec_factory.cpp.

                                        {
 
    // RLE Lossless (1.2.840.10008.1.2.5)
    if (transfer_syntax_uid == rle_codec::kTransferSyntaxUID) {
        return std::make_unique<rle_codec>();
    }
 
    // JPEG Baseline (Process 1)
    if (transfer_syntax_uid == jpeg_baseline_codec::kTransferSyntaxUID) {
        return std::make_unique<jpeg_baseline_codec>();
    }
 
    // JPEG Lossless (Process 14, Selection Value 1)
    if (transfer_syntax_uid == jpeg_lossless_codec::kTransferSyntaxUID) {
        return std::make_unique<jpeg_lossless_codec>();
    }
 
    // JPEG-LS Lossless (1.2.840.10008.1.2.4.80)
    if (transfer_syntax_uid == jpeg_ls_codec::kTransferSyntaxUIDLossless) {
        return std::make_unique<jpeg_ls_codec>(true);  // lossless = true
    }
 
    // JPEG-LS Near-Lossless (1.2.840.10008.1.2.4.81)
    if (transfer_syntax_uid == jpeg_ls_codec::kTransferSyntaxUIDNearLossless) {
        return std::make_unique<jpeg_ls_codec>(false);  // lossless = false
    }
 
    // JPEG 2000 Lossless Only (1.2.840.10008.1.2.4.90)
    if (transfer_syntax_uid == jpeg2000_codec::kTransferSyntaxUIDLossless) {
        return std::make_unique<jpeg2000_codec>(true);  // lossless = true
    }
 
    // JPEG 2000 (1.2.840.10008.1.2.4.91) - can be lossy or lossless
    if (transfer_syntax_uid == jpeg2000_codec::kTransferSyntaxUIDLossy) {
        return std::make_unique<jpeg2000_codec>(false);  // lossless = false (default lossy)
    }
 
    // HEVC/H.265 Main Profile (1.2.840.10008.1.2.4.107)
    if (transfer_syntax_uid == hevc_codec::kTransferSyntaxUIDMain) {
        return std::make_unique<hevc_codec>(false);  // main10 = false
    }
 
    // HEVC/H.265 Main 10 Profile (1.2.840.10008.1.2.4.108)
    if (transfer_syntax_uid == hevc_codec::kTransferSyntaxUIDMain10) {
        return std::make_unique<hevc_codec>(true);  // main10 = true
    }
 
    // JPEG XL Lossless (1.2.840.10008.1.2.4.110)
    if (transfer_syntax_uid == jpegxl_codec::kTransferSyntaxUIDLossless) {
        return std::make_unique<jpegxl_codec>(true, false);
    }
 
    // JPEG XL JPEG Recompression (1.2.840.10008.1.2.4.111)
    if (transfer_syntax_uid == jpegxl_codec::kTransferSyntaxUIDJPEGRecompression) {
        return std::make_unique<jpegxl_codec>(true, true);
    }
 
    // JPEG XL (1.2.840.10008.1.2.4.112) - lossy
    if (transfer_syntax_uid == jpegxl_codec::kTransferSyntaxUIDLossy) {
        return std::make_unique<jpegxl_codec>(false);
    }
 
    // HTJ2K Lossless Only (1.2.840.10008.1.2.4.201)
    if (transfer_syntax_uid == htj2k_codec::kTransferSyntaxUIDLossless) {
        return std::make_unique<htj2k_codec>(true, false);
    }
 
    // HTJ2K with RPCL Options (1.2.840.10008.1.2.4.202)
    if (transfer_syntax_uid == htj2k_codec::kTransferSyntaxUIDRPCL) {
        return std::make_unique<htj2k_codec>(true, true);
    }
 
    // HTJ2K (1.2.840.10008.1.2.4.203) - lossy
    if (transfer_syntax_uid == htj2k_codec::kTransferSyntaxUIDLossy) {
        return std::make_unique<htj2k_codec>(false);
    }
 
    // Frame Deflate (1.2.840.10008.1.2.11)
    if (transfer_syntax_uid == frame_deflate_codec::kTransferSyntaxUID) {
        return std::make_unique<frame_deflate_codec>();
    }
 
    return nullptr;
}

Referenced by create().

Here is the caller graph for this function:

◆ is_supported() [1/2]

bool kcenon::pacs::encoding::compression::codec_factory::is_supported ( const transfer_syntax & ts )

staticnodiscard

Checks if a Transfer Syntax is supported for compression.

Parameters

ts	The Transfer Syntax object

Returns: true if compression/decompression is supported

Definition at line 153 of file codec_factory.cpp.

                                                          {
    return is_supported(ts.uid());
}

References is_supported().

Here is the call graph for this function:

◆ is_supported() [2/2]

bool kcenon::pacs::encoding::compression::codec_factory::is_supported ( std::string_view transfer_syntax_uid )

staticnodiscard

Checks if a Transfer Syntax is supported for compression.

Parameters

transfer_syntax_uid The DICOM Transfer Syntax UID

Returns: true if compression/decompression is supported

Definition at line 144 of file codec_factory.cpp.

                                                                   {
    for (const auto& uid : kSupportedTransferSyntaxes) {
        if (uid == transfer_syntax_uid) {
            return true;
        }
    }
    return false;
}

References uid.

Referenced by is_supported().

Here is the caller graph for this function:

◆ supported_transfer_syntaxes()

std::vector< std::string_view > kcenon::pacs::encoding::compression::codec_factory::supported_transfer_syntaxes ( )

staticnodiscard

Returns a list of all supported Transfer Syntax UIDs.

Returns: Vector of supported UIDs for compression codecs

Definition at line 140 of file codec_factory.cpp.

                                                                     {
    return {kSupportedTransferSyntaxes.begin(), kSupportedTransferSyntaxes.end()};
}

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

include/kcenon/pacs/encoding/compression/codec_factory.h
src/encoding/compression/codec_factory.cpp

Static Public Member Functions

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ codec_factory()

Member Function Documentation

◆ create() [1/2]

◆ create() [2/2]

◆ is_supported() [1/2]

◆ is_supported() [2/2]

◆ supported_transfer_syntaxes()