NodeDistanceField.hpp

#pragma once
 
#include "DistanceTransformTypes.hpp"
 
#include <cstdint>
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
class NodeDistanceField {
  public:
    NodeDistanceField(NodeId node, int rows, int columns, DistanceTransformAccuracy accuracy, std::vector<PixelId> supportPixels,
                      std::vector<std::int64_t> squaredDistances)
        : node_(node), rows_(rows), columns_(columns), accuracy_(accuracy), supportPixels_(std::move(supportPixels)),
          squaredDistances_(std::move(squaredDistances)) {
        if (node < 0 || rows <= 0 || columns <= 0 || (accuracy != DistanceTransformAccuracy::Exact && accuracy != DistanceTransformAccuracy::Approximate) ||
            supportPixels_.empty() || supportPixels_.size() != squaredDistances_.size()) {
            throw std::invalid_argument("NodeDistanceField requires a live node and matching non-empty sample arrays.");
        }
        const std::size_t domainSize = static_cast<std::size_t>(rows_) * static_cast<std::size_t>(columns_);
        for (std::size_t index = 0; index < supportPixels_.size(); ++index) {
            if (supportPixels_[index] < 0 || static_cast<std::size_t>(supportPixels_[index]) >= domainSize || squaredDistances_[index] < 0) {
                throw std::invalid_argument("NodeDistanceField samples must belong to the domain and have non-negative squared distances.");
            }
        }
    }
 
    [[nodiscard]] NodeId node() const noexcept { return node_; }
    [[nodiscard]] int rows() const noexcept { return rows_; }
    [[nodiscard]] int columns() const noexcept { return columns_; }
    [[nodiscard]] DistanceTransformAccuracy accuracy() const noexcept { return accuracy_; }
    [[nodiscard]] std::size_t size() const noexcept { return supportPixels_.size(); }
    [[nodiscard]] std::span<const PixelId> supportPixels() const noexcept { return supportPixels_; }
    [[nodiscard]] std::span<const std::int64_t> squaredDistances() const noexcept { return squaredDistances_; }
 
    [[nodiscard]] std::vector<std::int64_t> denseSquaredDistances(std::int64_t outsideValue = -1) const {
        const std::size_t domainSize = static_cast<std::size_t>(rows_) * static_cast<std::size_t>(columns_);
        std::vector<std::int64_t> dense(domainSize, outsideValue);
        for (std::size_t index = 0; index < supportPixels_.size(); ++index) {
            dense[static_cast<std::size_t>(supportPixels_[index])] = squaredDistances_[index];
        }
        return dense;
    }
 
  private:
    NodeId node_ = InvalidNode;
    int rows_ = 0;
    int columns_ = 0;
    DistanceTransformAccuracy accuracy_ = DistanceTransformAccuracy::Exact;
    std::vector<PixelId> supportPixels_;
    std::vector<std::int64_t> squaredDistances_;
};
 
} // namespace mmcfilters