DistanceTransformProfiles.hpp

#pragma once
 
#include "DistanceTransformTypes.hpp"
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
class DistanceTransformProfiles {
  public:
    struct Span {
        std::size_t offset = 0;
        std::size_t size = 0;
    };
 
    DistanceTransformProfiles(DistanceTransformAccuracy accuracy, std::vector<DistanceTransformHistogramBin> bins, std::vector<Span> spans,
                              std::vector<std::uint8_t> alive)
        : accuracy_(accuracy), bins_(std::move(bins)), spans_(std::move(spans)), alive_(std::move(alive)) {
        if ((accuracy_ != DistanceTransformAccuracy::Exact && accuracy_ != DistanceTransformAccuracy::Approximate) || spans_.size() != alive_.size()) {
            throw std::invalid_argument("DistanceTransformProfiles requires aligned node spans and liveness flags.");
        }
        for (std::size_t node = 0; node < spans_.size(); ++node) {
            const Span span = spans_[node];
            if (span.offset > bins_.size() || span.size > bins_.size() - span.offset || (alive_[node] != 0 && span.size == 0) ||
                (alive_[node] == 0 && span.size != 0)) {
                throw std::invalid_argument("DistanceTransformProfiles received an invalid node histogram span.");
            }
            std::int64_t previousDistance = -1;
            for (std::size_t binIndex = span.offset; binIndex < span.offset + span.size; ++binIndex) {
                const DistanceTransformHistogramBin& bin = bins_[binIndex];
                if (bin.squaredDistance < 0 || bin.squaredDistance <= previousDistance || bin.count == 0) {
                    throw std::invalid_argument("DistanceTransformProfiles requires positive counts at strictly increasing non-negative levels.");
                }
                previousDistance = bin.squaredDistance;
            }
        }
    }
 
    [[nodiscard]] DistanceTransformAccuracy accuracy() const noexcept { return accuracy_; }
    [[nodiscard]] std::size_t numNodeSlots() const noexcept { return spans_.size(); }
    [[nodiscard]] std::size_t numBins() const noexcept { return bins_.size(); }
 
    [[nodiscard]] std::span<const DistanceTransformHistogramBin> histogram(NodeId node) const {
        const Span span = checkedSpan(node);
        return std::span<const DistanceTransformHistogramBin>(bins_.data() + span.offset, span.size);
    }
 
    [[nodiscard]] std::vector<DistanceTransformSurvivalBin> survivalProfile(NodeId node) const {
        const std::span<const DistanceTransformHistogramBin> nodeHistogram = histogram(node);
        std::uint64_t total = 0;
        for (const DistanceTransformHistogramBin& bin : nodeHistogram) {
            if (bin.count > std::numeric_limits<std::uint64_t>::max() - total) {
                throw std::overflow_error("Distance-transform survival profile exceeds the 64-bit count domain.");
            }
            total += bin.count;
        }
        std::vector<DistanceTransformSurvivalBin> result;
        result.reserve(nodeHistogram.size());
        std::uint64_t below = 0;
        for (const DistanceTransformHistogramBin& bin : nodeHistogram) {
            result.push_back({bin.squaredDistance, total - below});
            below += bin.count;
        }
        return result;
    }
 
  private:
    [[nodiscard]] Span checkedSpan(NodeId node) const {
        if (node < 0 || static_cast<std::size_t>(node) >= spans_.size() || alive_[static_cast<std::size_t>(node)] == 0) {
            throw std::out_of_range("Distance-transform profile access requires a live internal node id.");
        }
        return spans_[static_cast<std::size_t>(node)];
    }
 
    DistanceTransformAccuracy accuracy_ = DistanceTransformAccuracy::Exact;
    std::vector<DistanceTransformHistogramBin> bins_;
    std::vector<Span> spans_;
    std::vector<std::uint8_t> alive_;
};
 
} // namespace mmcfilters