Tensor3D.hpp

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cstddef>
#include <memory>
#include <vector>
 
#include <opencv2/core.hpp>
 
namespace volcart
{
template <typename DType>
class Tensor3D
{
public:
    Tensor3D<DType>() = default;
 
    Tensor3D<DType>(
        std::size_t x, std::size_t y, std::size_t z, bool zero = true)
        : dx_(x), dy_(y), dz_(z)
    {
        tensor_.reserve(dz_);
 
        // XXX check if these dimensions are too large?
        if (zero) {
            // Static vars are automatically initialized to zero, so it's a
            // convenient way to zero-initialize the tensor
            static DType d;
            for (std::size_t i = 0; i < dz_; ++i) {
                tensor_.emplace_back(dy_, dx_, d);
            }
        } else {
            for (std::size_t i = 0; i < dz_; ++i) {
                tensor_.emplace_back(dy_, dx_);
            }
        }
    }
    const DType& operator()(std::size_t x, std::size_t y, std::size_t z) const
    {
        assert(x < dx_ && x >= 0 && "index out of range");
        assert(y < dy_ && y >= 0 && "index out of range");
        assert(z < dz_ && z >= 0 && "index out of range");
        return tensor_[z](y, x);
    }
 
    DType& operator()(std::size_t x, std::size_t y, std::size_t z)
    {
        assert(x < dx_ && x >= 0 && "index out of range");
        assert(y < dy_ && y >= 0 && "index out of range");
        assert(z < dz_ && z >= 0 && "index out of range");
        return tensor_[z](y, x);
    }
    std::size_t dx() { return dx_; }
 
    std::size_t dx() const { return dx_; }
 
    std::size_t dy() { return dy_; }
 
    std::size_t dy() const { return dy_; }
 
    std::size_t dz() { return dz_; }
 
    std::size_t dz() const { return dz_; }
    const cv::Mat_<DType>& xySlice(std::size_t z) const { return tensor_[z]; }
 
    cv::Mat_<DType>& xySlice(std::size_t z) { return tensor_[z]; }
 
    cv::Mat_<DType> xzSlice(std::size_t y) const
    {
        cv::Mat_<DType> zSlice(dz_, dx_);
        for (std::size_t z = 0; z < dz_; ++z) {
            tensor_[z].row(y).copyTo(zSlice.row(z));
        }
        return zSlice;
    }
    std::unique_ptr<DType[]> buffer() const
    {
        auto buf = std::make_unique<DType[]>(dx_ * dy_ * dz_);
        for (std::size_t z = 0; z < dz_; ++z) {
            for (std::size_t y = 0; y < dy_; ++y) {
                for (std::size_t x = 0; x < dx_; ++x) {
                    buf[z * dx_ * dy_ + y * dx_ + x] = tensor_[z](y, x);
                }
            }
        }
        return buf;
    }
private:
    std::vector<cv::Mat_<DType>> tensor_;
    std::size_t dx_;
    std::size_t dy_;
    std::size_t dz_;
};
}  // namespace volcart
 
template <typename DType>
std::ostream& operator<<(
    std::ostream& s, const volcart::Tensor3D<DType>& tensor)
{
    for (std::size_t z = 0; z < tensor.dz_; ++z) {
        s << tensor.xySlice(z) << std::endl;
    }
    return s;
}