annotation_record.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.
 
#pragma once
 
#include <chrono>
#include <optional>
#include <string>
 
namespace kcenon::pacs::storage {
 
enum class annotation_type {
    arrow,      
    line,       
    rectangle,  
    ellipse,    
    polygon,    
    freehand,   
    text,       
    angle,      
    roi         
};
 
[[nodiscard]] inline auto to_string(annotation_type type) -> std::string {
    switch (type) {
        case annotation_type::arrow: return "arrow";
        case annotation_type::line: return "line";
        case annotation_type::rectangle: return "rectangle";
        case annotation_type::ellipse: return "ellipse";
        case annotation_type::polygon: return "polygon";
        case annotation_type::freehand: return "freehand";
        case annotation_type::text: return "text";
        case annotation_type::angle: return "angle";
        case annotation_type::roi: return "roi";
    }
    return "unknown";
}
 
[[nodiscard]] inline auto annotation_type_from_string(std::string_view str)
    -> std::optional<annotation_type> {
    if (str == "arrow") return annotation_type::arrow;
    if (str == "line") return annotation_type::line;
    if (str == "rectangle") return annotation_type::rectangle;
    if (str == "ellipse") return annotation_type::ellipse;
    if (str == "polygon") return annotation_type::polygon;
    if (str == "freehand") return annotation_type::freehand;
    if (str == "text") return annotation_type::text;
    if (str == "angle") return annotation_type::angle;
    if (str == "roi") return annotation_type::roi;
    return std::nullopt;
}
 
struct annotation_style {
    std::string color{"#FFFF00"};        
    int line_width{2};                   
    std::string fill_color;              
    float fill_opacity{0.0f};            
    std::string font_family{"Arial"};    
    int font_size{14};                   
};
 
struct annotation_record {
    int64_t pk{0};
 
    std::string annotation_id;
 
    std::string study_uid;
 
    std::string series_uid;
 
    std::string sop_instance_uid;
 
    std::optional<int> frame_number;
 
    std::string user_id;
 
    annotation_type type{annotation_type::text};
 
    std::string geometry_json;
 
    std::string text;
 
    annotation_style style;
 
    std::chrono::system_clock::time_point created_at;
 
    std::chrono::system_clock::time_point updated_at;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !annotation_id.empty() && !study_uid.empty();
    }
};
 
struct annotation_query {
    std::optional<std::string> study_uid;
 
    std::optional<std::string> series_uid;
 
    std::optional<std::string> sop_instance_uid;
 
    std::optional<std::string> user_id;
 
    std::optional<annotation_type> type;
 
    size_t limit{0};
 
    size_t offset{0};
 
    [[nodiscard]] auto has_criteria() const noexcept -> bool {
        return study_uid.has_value() || series_uid.has_value() ||
               sop_instance_uid.has_value() || user_id.has_value() ||
               type.has_value();
    }
};
 
}  // namespace kcenon::pacs::storage