measurement_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 measurement_type {
    length,         
    area,           
    angle,          
    hounsfield,     
    suv,            
    ellipse_area,   
    polygon_area    
};
 
[[nodiscard]] inline auto to_string(measurement_type type) -> std::string {
    switch (type) {
        case measurement_type::length: return "length";
        case measurement_type::area: return "area";
        case measurement_type::angle: return "angle";
        case measurement_type::hounsfield: return "hounsfield";
        case measurement_type::suv: return "suv";
        case measurement_type::ellipse_area: return "ellipse_area";
        case measurement_type::polygon_area: return "polygon_area";
    }
    return "unknown";
}
 
[[nodiscard]] inline auto measurement_type_from_string(std::string_view str)
    -> std::optional<measurement_type> {
    if (str == "length") return measurement_type::length;
    if (str == "area") return measurement_type::area;
    if (str == "angle") return measurement_type::angle;
    if (str == "hounsfield") return measurement_type::hounsfield;
    if (str == "suv") return measurement_type::suv;
    if (str == "ellipse_area") return measurement_type::ellipse_area;
    if (str == "polygon_area") return measurement_type::polygon_area;
    return std::nullopt;
}
 
struct measurement_record {
    int64_t pk{0};
 
    std::string measurement_id;
 
    std::string sop_instance_uid;
 
    std::optional<int> frame_number;
 
    std::string user_id;
 
    measurement_type type{measurement_type::length};
 
    std::string geometry_json;
 
    double value{0.0};
 
    std::string unit;
 
    std::string label;
 
    std::chrono::system_clock::time_point created_at;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !measurement_id.empty() && !sop_instance_uid.empty();
    }
};
 
struct measurement_query {
    std::optional<std::string> sop_instance_uid;
 
    std::optional<std::string> study_uid;
 
    std::optional<std::string> user_id;
 
    std::optional<measurement_type> type;
 
    size_t limit{0};
 
    size_t offset{0};
 
    [[nodiscard]] auto has_criteria() const noexcept -> bool {
        return sop_instance_uid.has_value() || study_uid.has_value() ||
               user_id.has_value() || type.has_value();
    }
};
 
}  // namespace kcenon::pacs::storage