PointSet.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <opencv2/core.hpp>
 
namespace volcart
{
template <typename T>
class PointSet
{
public:
    using Point = T;
 
    using value_type = Point;
 
    using Container = std::vector<Point>;
 
    using Iterator = typename Container::iterator;
 
    using ConstIterator = typename Container::const_iterator;
 
    constexpr static int FORMAT_VERSION = 1;
 
    constexpr static auto HEADER_TERMINATOR = "<>";
 
    constexpr static auto HEADER_TERMINATOR_REGEX = "^<>$";
 
    using Pointer = std::shared_ptr<PointSet<T>>;
 
    explicit PointSet() = default;
 
    explicit PointSet(std::size_t initSize) { data_.reserve(initSize); }
 
    explicit PointSet(std::size_t initSize, T initVal)
    {
        data_.assign(initSize, initVal);
    }
    const T& operator[](std::size_t idx) const
    {
        assert(idx < data_.size() && "idx out of range");
        return data_[idx];
    }
 
    T& operator[](std::size_t idx)
    {
        assert(idx < data_.size() && "idx out of range");
        return data_[idx];
    }
    std::size_t size() const { return data_.size(); }
 
    bool empty() const { return data_.empty(); }
 
    Container as_vector() { return data_; }
 
    void clear() { data_.clear(); }
    void push_back(const T& val) { data_.push_back(val); }
 
    void push_back(T&& val) { data_.push_back(val); }
 
    template <class... Args>
    void emplace_back(Args&&... args)
    {
        data_.emplace_back(std::forward<Args>(args)...);
    }
 
    template <class ContainerType>
    void append(const ContainerType& c)
    {
        std::copy(std::begin(c), std::end(c), std::back_inserter(data_));
    }
    Iterator begin() { return std::begin(data_); }
 
    ConstIterator begin() const { return std::begin(data_); }
 
    Iterator end() { return std::end(data_); }
 
    ConstIterator end() const { return std::end(data_); }
 
    T& front() { return data_.front(); }
 
    const T& front() const { return data_.front(); }
 
    T& back() { return data_.back(); }
 
    const T& back() const { return data_.back(); }
    T min() const
    {
        if (empty()) {
            throw std::range_error("empty PointSet");
        }
        return *std::min_element(
            std::begin(data_), std::end(data_),
            [](auto lhs, auto rhs) { return cv::norm(lhs) < cv::norm(rhs); });
    }
 
    T max() const
    {
        if (empty()) {
            throw std::range_error("empty PointSet");
        }
        return *std::max_element(
            std::begin(data_), std::end(data_),
            [](auto lhs, auto rhs) { return cv::norm(lhs) < cv::norm(rhs); });
    }
 
    std::pair<T, T> minMax() const
    {
        if (empty()) {
            throw std::range_error("empty PointSet");
        }
        auto pair = std::minmax_element(
            std::begin(data_), std::end(data_),
            [](auto lhs, auto rhs) { return cv::norm(lhs) < cv::norm(rhs); });
        return {*pair.first, *pair.second};
    }
    static PointSet Fill(std::size_t initSize, T initVal)
    {
        return PointSet(initSize, initVal);
    }
protected:
    Container data_;
};
}  // namespace volcart