image_params.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#ifndef PACS_ENCODING_COMPRESSION_IMAGE_PARAMS_HPP
#define PACS_ENCODING_COMPRESSION_IMAGE_PARAMS_HPP
 
#include <cstdint>
#include <string>
 
namespace kcenon::pacs::encoding::compression {
 
enum class photometric_interpretation {
    monochrome1,     
    monochrome2,     
    rgb,             
    ycbcr_full,      
    ycbcr_full_422,  
    palette_color,   
    unknown          
};
 
[[nodiscard]] inline std::string to_string(photometric_interpretation pi) {
    switch (pi) {
        case photometric_interpretation::monochrome1:
            return "MONOCHROME1";
        case photometric_interpretation::monochrome2:
            return "MONOCHROME2";
        case photometric_interpretation::rgb:
            return "RGB";
        case photometric_interpretation::ycbcr_full:
            return "YBR_FULL";
        case photometric_interpretation::ycbcr_full_422:
            return "YBR_FULL_422";
        case photometric_interpretation::palette_color:
            return "PALETTE COLOR";
        default:
            return "UNKNOWN";
    }
}
 
[[nodiscard]] inline photometric_interpretation parse_photometric_interpretation(
    const std::string& str) {
    if (str == "MONOCHROME1") return photometric_interpretation::monochrome1;
    if (str == "MONOCHROME2") return photometric_interpretation::monochrome2;
    if (str == "RGB") return photometric_interpretation::rgb;
    if (str == "YBR_FULL") return photometric_interpretation::ycbcr_full;
    if (str == "YBR_FULL_422") return photometric_interpretation::ycbcr_full_422;
    if (str == "PALETTE COLOR") return photometric_interpretation::palette_color;
    return photometric_interpretation::unknown;
}
 
struct image_params {
    uint16_t width{0};
 
    uint16_t height{0};
 
    uint16_t bits_allocated{0};
 
    uint16_t bits_stored{0};
 
    uint16_t high_bit{0};
 
    uint16_t samples_per_pixel{1};
 
    uint16_t planar_configuration{0};
 
    uint16_t pixel_representation{0};
 
    photometric_interpretation photometric{photometric_interpretation::monochrome2};
 
    uint32_t number_of_frames{1};
 
    [[nodiscard]] size_t frame_size_bytes() const noexcept {
        size_t bits_per_pixel = static_cast<size_t>(bits_allocated) * samples_per_pixel;
        size_t total_bits = static_cast<size_t>(width) * height * bits_per_pixel;
        return (total_bits + 7) / 8;  // Round up to byte boundary
    }
 
    [[nodiscard]] bool is_grayscale() const noexcept {
        return samples_per_pixel == 1;
    }
 
    [[nodiscard]] bool is_color() const noexcept {
        return samples_per_pixel > 1;
    }
 
    [[nodiscard]] bool is_signed() const noexcept {
        return pixel_representation == 1;
    }
 
    [[nodiscard]] bool valid_for_jpeg_baseline() const noexcept {
        if (bits_allocated != 8 || bits_stored != 8) return false;
        if (samples_per_pixel != 1 && samples_per_pixel != 3) return false;
        return true;
    }
 
    [[nodiscard]] bool valid_for_jpeg_lossless() const noexcept {
        if (bits_stored < 2 || bits_stored > 16) return false;
        if (bits_allocated != 8 && bits_allocated != 16) return false;
        if (samples_per_pixel != 1) return false;
        return true;
    }
 
    [[nodiscard]] bool valid_for_jpeg2000() const noexcept {
        if (bits_stored < 1 || bits_stored > 16) return false;
        if (bits_allocated != 8 && bits_allocated != 16) return false;
        if (samples_per_pixel != 1 && samples_per_pixel != 3) return false;
        if (width == 0 || height == 0) return false;
        return true;
    }
 
    [[nodiscard]] bool valid_for_jpeg_ls() const noexcept {
        if (bits_stored < 2 || bits_stored > 16) return false;
        if (bits_allocated != 8 && bits_allocated != 16) return false;
        if (samples_per_pixel != 1 && samples_per_pixel != 3) return false;
        if (width == 0 || height == 0) return false;
        if (width > 65535 || height > 65535) return false;
        return true;
    }
 
    [[nodiscard]] bool valid_for_rle() const noexcept {
        if (bits_allocated != 8 && bits_allocated != 16) return false;
        if (samples_per_pixel < 1 || samples_per_pixel > 3) return false;
        if (width == 0 || height == 0) return false;
        if (width > 65535 || height > 65535) return false;
        // Check segment count limit (max 15 segments)
        int bytes_per_sample = (bits_allocated + 7) / 8;
        int num_segments = samples_per_pixel * bytes_per_sample;
        if (num_segments > 15) return false;
        return true;
    }
};
 
}  // namespace kcenon::pacs::encoding::compression
 
#endif  // PACS_ENCODING_COMPRESSION_IMAGE_PARAMS_HPP