OrderedPointSet.hpp

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cstddef>
#include <iostream>
#include <memory>
#include <stdexcept>
 
#include "Exceptions.hpp"
#include "PointSet.hpp"
 
namespace volcart
{
template <typename T>
class OrderedPointSet : public PointSet<T>
{
public:
    using BaseClass = PointSet<T>;
    using BaseClass::BaseClass;
    using BaseClass::data_;
 
    using Pointer = std::shared_ptr<OrderedPointSet<T>>;
 
    explicit OrderedPointSet() = default;
 
    explicit OrderedPointSet(std::size_t width) : BaseClass(), width_(width)
    {
        data_.reserve(width_ * CAPACITY_MULTIPLIER);
    }
 
    explicit OrderedPointSet(std::size_t width, T initVal)
        : BaseClass(), width_(width)
    {
        data_.assign(width_ * CAPACITY_MULTIPLIER, initVal);
    }
    const T& operator()(std::size_t y, std::size_t x) const
    {
        assert(x < width_ && "x out of range");
        assert(y * width_ + x < data_.size() && "(x, y) out of range");
        return data_[y * width_ + x];
    }
 
    T& operator()(std::size_t y, std::size_t x)
    {
        assert(x < width_ && "x out of range");
        assert(y * width_ + x < data_.size() && "(x, y) out of range");
        return data_[y * width_ + x];
    }
    std::size_t width() const { return width_; }
 
    // data_.size() should be a perfect multiple of width_, so this should
    // return a whole integer
    std::size_t height() const
    {
        return (width_ == 0 ? 0 : this->size() / width_);
    }
 
    void setWidth(std::size_t width)
    {
        if (width_ != 0) {
            auto msg = "Cannot change width if already set";
            throw std::logic_error(msg);
        }
        width_ = width;
    }
 
    void reset()
    {
        width_ = 0;
        this->clear();
    }
    void pushRow(const std::vector<T>& points)
    {
        assert(points.size() == width_ && "row incorrect size");
        std::copy(
            std::begin(points), std::end(points), std::back_inserter(data_));
    }
 
    void pushRow(std::vector<T>&& points)
    {
        assert(points.size() == width_ && "row incorrect size");
        std::copy(
            std::begin(points), std::end(points), std::back_inserter(data_));
    }
 
    // Cannot add individual points to this class because it would break
    // width constraint calculation
    void push_back(const T& val) = delete;
    void push_back(T&& val) = delete;
    void emplace_back(const T& val) = delete;
    void emplace_back(T&& val) = delete;
 
    void append(const OrderedPointSet<T>& ps)
    {
        // ps must be same width as this pointset
        if (width_ != ps.width()) {
            auto msg = "Cannot append pointset with different width";
            throw std::logic_error(msg);
        }
 
        std::copy(std::begin(ps), std::end(ps), std::back_inserter(data_));
    }
 
    std::vector<T> getRow(std::size_t i) const
    {
        if (i >= this->height()) {
            throw std::range_error("get row: i out of range");
        }
        std::vector<T> row(width_);
        std::copy(
            std::begin(data_) + width_ * i,
            std::begin(data_) + width_ * (i + 1), std::begin(row));
        return row;
    }
 
    OrderedPointSet copyRows(std::size_t i, std::size_t j) const
    {
        if (i >= this->height()) {
            throw std::range_error("copy row: i out of range");
        }
        if (j > this->height()) {
            throw std::range_error("copy row: j out of range");
        }
        if (i == j) {
            return OrderedPointSet(width_);
        }
        if (j < i) {
            throw std::logic_error("i must be less than j");
        }
        OrderedPointSet ps(width_);
        std::copy(
            std::begin(data_) + width_ * i, std::begin(data_) + width_ * j,
            std::back_inserter(ps.data_));
        return ps;
    }
    static OrderedPointSet Fill(
        std::size_t width, std::size_t height, T initVal)
    {
        OrderedPointSet ps(width);
        std::vector<T> v;
        v.assign(width, initVal);
        for (std::size_t _ = 0; _ < height; ++_) {
            ps.pushRow(v);
        }
        return ps;
    }
private:
    std::size_t width_{0};
    constexpr static std::size_t CAPACITY_MULTIPLIER = 20;
};
}  // namespace volcart