SinogramClassic3D.h

Go to the documentation of this file.

#pragma once
 
#include "Common.h"
#include "Texture.h"
 
namespace reg23 {
 
template <typename texture_t> class SinogramClassic3D : texture_t {
public:
    using Base = texture_t;
    static_assert(Base::DIMENSIONALITY == 3, "The texture type of a `SinogramClassic3D` must have dimensionality 3.");
    using IntType = typename Base::IntType;
    using FloatType = typename Base::FloatType;
    using SizeType = typename Base::SizeType;
    using VectorType = typename Base::VectorType;
    using AddressModeType = typename Base::AddressModeType;
 
    static constexpr FloatType THETA_RANGE_LOW = -.5 * M_PI;
    static constexpr FloatType THETA_RANGE_HIGH = .5 * M_PI;
    static constexpr FloatType PHI_RANGE_LOW = -.5 * M_PI;
    static constexpr FloatType PHI_RANGE_HIGH = .5 * M_PI;
 
    SinogramClassic3D() = default;
 
    explicit SinogramClassic3D(Base texture) : Base(std::move(texture)) {
        mappingRThetaPhiToTexCoord = Base::MappingWorldToTexCoord();
    }
 
    // yes copy
    SinogramClassic3D(const SinogramClassic3D &) = default;
 
    SinogramClassic3D &operator=(const SinogramClassic3D &) = default;
 
    // yes move
    SinogramClassic3D(SinogramClassic3D &&) = default;
 
    SinogramClassic3D &operator=(SinogramClassic3D &&) = default;
 
    static SinogramClassic3D FromTensor(const at::Tensor &tensor, FloatType rSpacing) {
        // tensor should be a 3D array of floats
        TORCH_CHECK(tensor.sizes().size() == 3)
        TORCH_CHECK(tensor.dtype() == at::kFloat)
        const SizeType tensorSizeRThetaPhi = SizeType::FromIntArrayRef(tensor.sizes()).Flipped();
        const FloatType thetaSpacing = (THETA_RANGE_HIGH - THETA_RANGE_LOW) / static_cast<FloatType>(
                                           tensorSizeRThetaPhi[1] - 2);
        const FloatType phiSpacing = (PHI_RANGE_HIGH - PHI_RANGE_LOW) / static_cast<FloatType>(
                                         tensorSizeRThetaPhi[2] - 2);
        return SinogramClassic3D{Base::FromTensor(tensor, {rSpacing, thetaSpacing, phiSpacing})};
    }
 
    static SinogramClassic3D FromCUDAHandle(int64_t textureHandle, const Vec<int64_t, 3> &sizeRThetaPhi,
                                            FloatType rSpacing) {
        const FloatType thetaSpacing = (THETA_RANGE_HIGH - THETA_RANGE_LOW) / static_cast<FloatType>(
                                           sizeRThetaPhi[1] - 2);
        const FloatType phiSpacing = (PHI_RANGE_HIGH - PHI_RANGE_LOW) / static_cast<FloatType>(sizeRThetaPhi[2] - 2);
        return SinogramClassic3D{
            Base{textureHandle, sizeRThetaPhi, {rSpacing, thetaSpacing, phiSpacing}, VectorType::Full(0)}};
    }
 
    [[nodiscard]] __host__ __device__ float Sample(const VectorType &rThetaPhi) const {
        return Base::Sample(mappingRThetaPhiToTexCoord(rThetaPhi));
    }
 
private:
    Linear<VectorType> mappingRThetaPhiToTexCoord{};
};
 
} // namespace reg23