Tensor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
 
#ifndef CVCORE_TENSOR_H
#define CVCORE_TENSOR_H
 
#include <initializer_list>
#include <stdexcept>
#include <string>
#include <type_traits>
 
namespace cvcore {
 
// there is no CUDA dependency at the data level, so we map half type to uint16_t for now
using half = std::uint16_t;
 
enum TensorLayout
{
    LC,          
    CL,          
    HWC,         
    CHW,         
    DHWC,        
    NHWC = DHWC, 
    DCHW,        
    NCHW = DCHW, 
    CDHW,        
};
 
enum ChannelCount
{
    C1, 
    C2, 
    C3, 
    C4, 
    CX, 
};
 
enum ChannelType
{
    U8,  
    U16, 
    S8,  
    S16, 
    F16, 
    F32, 
    F64, 
};
 
enum class TensorDimension
{
    LENGTH,  
    HEIGHT,  
    WIDTH,   
    CHANNEL, 
    DEPTH,   
};
 
std::string GetTensorLayoutAsString(TensorLayout TL);
 
std::string GetChannelCountAsString(ChannelCount CC);
 
std::string GetChannelTypeAsString(ChannelType CT);
 
std::string GetMemoryTypeAsString(bool isCPU);
 
std::size_t GetChannelSize(ChannelType CT);
 
class TensorBase
{
public:
    struct DimData
    {
        std::size_t size;   
        std::size_t stride; 
    };
 
    TensorBase(ChannelType type, const DimData *dimData, int dimCount, void *dataPtr, bool isCPU);
 
    TensorBase(ChannelType type, std::initializer_list<DimData> dimData, void *dataPtr, bool isCPU);
 
    TensorBase(ChannelType type, const DimData *dimData, int dimCount, bool isCPU);
 
    TensorBase(ChannelType type, std::initializer_list<DimData> dimData, bool isCPU);
 
    ~TensorBase();
 
    TensorBase(const TensorBase &) = delete;
 
    TensorBase &operator=(const TensorBase &) = delete;
 
    TensorBase(TensorBase &&);
 
    TensorBase &operator=(TensorBase &&);
 
    int getDimCount() const;
 
    std::size_t getSize(int dimIdx) const;
 
    std::size_t getStride(int dimIdx) const;
 
    ChannelType getType() const;
 
    void *getData() const;
 
    std::size_t getDataSize() const;
 
    bool isCPU() const;
 
    bool isOwning() const;
 
protected:
    TensorBase();
 
private:
    static constexpr int kMinDimCount = 2;
    static constexpr int kMaxDimCount = 4;
 
    void *m_data;
 
    int m_dimCount;
    DimData m_dimData[kMaxDimCount];
 
    ChannelType m_type;
    bool m_isOwning;
    bool m_isCPU;
};
 
namespace detail {
 
template<TensorLayout TL>
struct DimToIndex2D
{
    static_assert(TL == LC || TL == CL, "unsupported variant!");
    static constexpr int kLength  = TL == LC ? 0 : 1;
    static constexpr int kChannel = TL == LC ? 1 : 0;
};
 
template<TensorLayout TL>
struct DimToIndex3D
{
    static_assert(TL == HWC || TL == CHW, "unsupported variant!");
    static constexpr int kWidth   = TL == HWC ? 1 : 2;
    static constexpr int kHeight  = TL == HWC ? 0 : 1;
    static constexpr int kChannel = TL == HWC ? 2 : 0;
};
 
template<TensorLayout TL>
struct DimToIndex4D
{
    static_assert(TL == DHWC || TL == DCHW || TL == CDHW, "unsupported variant!");
    static constexpr int kWidth   = TL == DHWC ? 2 : (TL == DCHW ? 3 : 3);
    static constexpr int kHeight  = TL == DHWC ? 1 : (TL == DCHW ? 2 : 2);
    static constexpr int kDepth   = TL == DHWC ? 0 : (TL == DCHW ? 0 : 1);
    static constexpr int kChannel = TL == DHWC ? 3 : (TL == DCHW ? 1 : 0);
};
 
template<TensorLayout TL, typename = void>
struct LayoutToIndex
{
};
 
template<TensorLayout TL>
struct LayoutToIndex<TL, typename std::enable_if<TL == LC || TL == CL>::type> : public DimToIndex2D<TL>
{
    static constexpr int kDimCount = 2;
};
 
template<TensorLayout TL>
struct LayoutToIndex<TL, typename std::enable_if<TL == HWC || TL == CHW>::type> : public DimToIndex3D<TL>
{
    static constexpr int kDimCount = 3;
};
 
template<TensorLayout TL>
struct LayoutToIndex<TL, typename std::enable_if<TL == DHWC || TL == DCHW || TL == CDHW>::type>
    : public DimToIndex4D<TL>
{
    static constexpr int kDimCount = 4;
};
 
template<ChannelType CT>
struct ChannelTypeToNative
{
};
 
template<>
struct ChannelTypeToNative<U8>
{
    using Type = std::uint8_t;
};
 
template<>
struct ChannelTypeToNative<U16>
{
    using Type = std::uint16_t;
};
 
template<>
struct ChannelTypeToNative<S8>
{
    using Type = std::int8_t;
};
 
template<>
struct ChannelTypeToNative<S16>
{
    using Type = std::int16_t;
};
 
template<>
struct ChannelTypeToNative<F32>
{
    using Type = float;
};
 
template<>
struct ChannelTypeToNative<F16>
{
    using Type = cvcore::half;
};
 
template<>
struct ChannelTypeToNative<F64>
{
    using Type = double;
};
 
template<ChannelCount CC>
constexpr std::size_t ChannelToCount()
{
    switch (CC)
    {
    case C1:
        return 1;
    case C2:
        return 2;
    case C3:
        return 3;
    case C4:
        return 4;
    }
    return 0; // this is safe as this function will never be called for dynamic channel counts
}
 
template<TensorLayout TL, ChannelType CT>
class Tensor2D : public TensorBase
{
    using DataType = typename ChannelTypeToNative<CT>::Type;
 
public:
    Tensor2D() = default;
 
    Tensor2D(std::initializer_list<DimData> dimData, bool isCPU)
        : TensorBase(CT, dimData, isCPU)
    {
    }
 
    Tensor2D(std::initializer_list<DimData> dimData, DataType *dataPtr, bool isCPU)
        : TensorBase(CT, dimData, dataPtr, isCPU)
    {
    }
 
    std::size_t getLength() const
    {
        return getSize(DimToIndex2D<TL>::kLength);
    }
 
    std::size_t getChannelCount() const
    {
        return getSize(DimToIndex2D<TL>::kChannel);
    }
 
    using TensorBase::getStride;
 
    std::size_t getStride(TensorDimension dim) const
    {
        switch (dim)
        {
        case TensorDimension::LENGTH:
            return getStride(DimToIndex2D<TL>::kLength);
        case TensorDimension::CHANNEL:
            return getStride(DimToIndex2D<TL>::kChannel);
        default:
            throw std::out_of_range("cvcore::Tensor2D::getStride ==> Requested TensorDimension is out of bounds");
        }
    }
 
    DataType *getData()
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
 
    const DataType *getData() const
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
};
 
template<TensorLayout TL, ChannelType CT>
class Tensor3D : public TensorBase
{
    using DataType = typename ChannelTypeToNative<CT>::Type;
 
public:
    Tensor3D() = default;
 
    Tensor3D(std::initializer_list<DimData> dimData, bool isCPU)
        : TensorBase(CT, dimData, isCPU)
    {
    }
 
    Tensor3D(std::initializer_list<DimData> dimData, DataType *dataPtr, bool isCPU)
        : TensorBase(CT, dimData, dataPtr, isCPU)
    {
    }
 
    std::size_t getWidth() const
    {
        return getSize(DimToIndex3D<TL>::kWidth);
    }
 
    std::size_t getHeight() const
    {
        return getSize(DimToIndex3D<TL>::kHeight);
    }
 
    std::size_t getChannelCount() const
    {
        return getSize(DimToIndex3D<TL>::kChannel);
    }
 
    using TensorBase::getStride;
 
    std::size_t getStride(TensorDimension dim) const
    {
        switch (dim)
        {
        case TensorDimension::HEIGHT:
            return getStride(DimToIndex3D<TL>::kHeight);
        case TensorDimension::WIDTH:
            return getStride(DimToIndex3D<TL>::kWidth);
        case TensorDimension::CHANNEL:
            return getStride(DimToIndex3D<TL>::kChannel);
        default:
            throw std::out_of_range("cvcore::Tensor3D::getStride ==> Requested TensorDimension is out of bounds");
        }
    }
 
    DataType *getData()
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
 
    const DataType *getData() const
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
};
 
template<TensorLayout TL, ChannelType CT>
class Tensor4D : public TensorBase
{
    using DataType = typename ChannelTypeToNative<CT>::Type;
 
public:
    Tensor4D() = default;
 
    Tensor4D(std::initializer_list<DimData> dimData, bool isCPU)
        : TensorBase(CT, dimData, isCPU)
    {
    }
 
    Tensor4D(std::initializer_list<DimData> dimData, DataType *dataPtr, bool isCPU)
        : TensorBase(CT, dimData, dataPtr, isCPU)
    {
    }
 
    std::size_t getWidth() const
    {
        return getSize(DimToIndex4D<TL>::kWidth);
    }
 
    std::size_t getHeight() const
    {
        return getSize(DimToIndex4D<TL>::kHeight);
    }
 
    std::size_t getDepth() const
    {
        return getSize(DimToIndex4D<TL>::kDepth);
    }
 
    std::size_t getChannelCount() const
    {
        return getSize(DimToIndex4D<TL>::kChannel);
    }
 
    using TensorBase::getStride;
 
    std::size_t getStride(TensorDimension dim) const
    {
        switch (dim)
        {
        case TensorDimension::HEIGHT:
            return getStride(DimToIndex4D<TL>::kHeight);
        case TensorDimension::WIDTH:
            return getStride(DimToIndex4D<TL>::kWidth);
        case TensorDimension::CHANNEL:
            return getStride(DimToIndex4D<TL>::kChannel);
        case TensorDimension::DEPTH:
            return getStride(DimToIndex4D<TL>::kDepth);
        default:
            throw std::out_of_range("cvcore::Tensor4D::getStride ==> Requested TensorDimension is out of bounds");
        }
    }
 
    DataType *getData()
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
 
    const DataType *getData() const
    {
        return reinterpret_cast<DataType *>(TensorBase::getData());
    }
};
 
} // namespace detail
 
template<TensorLayout TL, ChannelCount CC, ChannelType CT>
class Tensor;
 
// 2D Tensors
 
template<ChannelCount CC, ChannelType CT>
class Tensor<LC, CC, CT> : public detail::Tensor2D<LC, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t length, bool isCPU = true)
        : detail::Tensor2D<LC, CT>({{length, detail::ChannelToCount<CC>()}, {detail::ChannelToCount<CC>(), 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t length, std::size_t channelCount, bool isCPU = true)
        : detail::Tensor2D<LC, CT>({{length, channelCount}, {channelCount, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t length, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor2D<LC, CT>({{length, detail::ChannelToCount<CC>()}, {detail::ChannelToCount<CC>(), 1}}, dataPtr,
                                   isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t length, std::size_t channelCount, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor2D<LC, CT>({{length, channelCount}, {channelCount, 1}}, dataPtr, isCPU)
    {
    }
};
 
template<ChannelCount CC, ChannelType CT>
class Tensor<CL, CC, CT> : public detail::Tensor2D<CL, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t length, bool isCPU = true)
        : detail::Tensor2D<CL, CT>({{detail::ChannelToCount<CC>(), length}, {length, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t length, std::size_t channelCount, bool isCPU = true)
        : detail::Tensor2D<CL, CT>({{channelCount, length}, {length, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t length, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor2D<CL, CT>({{detail::ChannelToCount<CC>(), length}, {length, 1}}, dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t length, std::size_t channelCount, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor2D<CL, CT>({{channelCount, length}, {length, 1}}, dataPtr, isCPU)
    {
    }
};
 
// 3D Tensors
 
template<ChannelCount CC, ChannelType CT>
class Tensor<HWC, CC, CT> : public detail::Tensor3D<HWC, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, width * detail::ChannelToCount<CC>()},
                                     {width, detail::ChannelToCount<CC>()},
                                     {detail::ChannelToCount<CC>(), 1}},
                                    isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, width * channelCount}, {width, channelCount}, {channelCount, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, DataType *dataPtr, B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, width * detail::ChannelToCount<CC>()},
                                     {width, detail::ChannelToCount<CC>()},
                                     {detail::ChannelToCount<CC>(), 1}},
                                    dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t rowPitch, DataType *dataPtr, B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, rowPitch / GetChannelSize(CT)},
                                     {width, detail::ChannelToCount<CC>()},
                                     {detail::ChannelToCount<CC>(), 1}},
                                    dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<HWC, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, DataType *dataPtr, B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, width * channelCount}, {width, channelCount}, {channelCount, 1}}, dataPtr,
                                    isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, std::size_t rowPitch, DataType *dataPtr,
           B isCPU = true)
        : detail::Tensor3D<HWC, CT>({{height, rowPitch / GetChannelSize(CT)}, {width, channelCount}, {channelCount, 1}},
                                    dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<HWC, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
};
 
template<ChannelCount CC, ChannelType CT>
class Tensor<CHW, CC, CT> : public detail::Tensor3D<CHW, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, bool isCPU = true)
        : detail::Tensor3D<CHW, CT>({{detail::ChannelToCount<CC>(), width * height}, {height, width}, {width, 1}},
                                    isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, bool isCPU = true)
        : detail::Tensor3D<CHW, CT>({{channelCount, width * height}, {height, width}, {width, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor3D<CHW, CT>({{detail::ChannelToCount<CC>(), width * height}, {height, width}, {width, 1}},
                                    dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t rowPitch, DataType *dataPtr, B isCPU = true)
        : detail::Tensor3D<CHW, CT>({{detail::ChannelToCount<CC>(), height * rowPitch / GetChannelSize(CT)},
                                     {height, rowPitch / GetChannelSize(CT)},
                                     {width, 1}},
                                    dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<CHW, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor3D<CHW, CT>({{channelCount, width * height}, {height, width}, {width, 1}}, dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t channelCount, std::size_t rowPitch, DataType *dataPtr,
           B isCPU = true)
        : detail::Tensor3D<CHW, CT>({{channelCount, height * rowPitch / GetChannelSize(CT)},
                                     {height, rowPitch / GetChannelSize(CT)},
                                     {width, 1}},
                                    dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<CHW, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
};
 
// 4D Tensors
 
template<ChannelCount CC, ChannelType CT>
class Tensor<DHWC, CC, CT> : public detail::Tensor4D<DHWC, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * width * detail::ChannelToCount<CC>()},
                                      {height, width * detail::ChannelToCount<CC>()},
                                      {width, detail::ChannelToCount<CC>()},
                                      {detail::ChannelToCount<CC>(), 1}},
                                     isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * width * channelCount},
                                      {height, width * channelCount},
                                      {width, channelCount},
                                      {channelCount, 1}},
                                     isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, DataType *dataPtr, B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * width * detail::ChannelToCount<CC>()},
                                      {height, width * detail::ChannelToCount<CC>()},
                                      {width, detail::ChannelToCount<CC>()},
                                      {detail::ChannelToCount<CC>(), 1}},
                                     dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t rowPitch, DataType *dataPtr,
           B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * rowPitch / GetChannelSize(CT)},
                                      {height, rowPitch / GetChannelSize(CT)},
                                      {width, detail::ChannelToCount<CC>()},
                                      {detail::ChannelToCount<CC>(), 1}},
                                     dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<DHWC, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, DataType *dataPtr,
           B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * width * channelCount},
                                      {height, width * channelCount},
                                      {width, channelCount},
                                      {channelCount, 1}},
                                     dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, std::size_t rowPitch,
           DataType *dataPtr, B isCPU = true)
        : detail::Tensor4D<DHWC, CT>({{depth, height * rowPitch / GetChannelSize(CT)},
                                      {height, rowPitch / GetChannelSize(CT)},
                                      {width, channelCount},
                                      {channelCount, 1}},
                                     dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<DHWC, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
};
 
template<ChannelCount CC, ChannelType CT>
class Tensor<DCHW, CC, CT> : public detail::Tensor4D<DCHW, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, bool isCPU = true)
        : detail::Tensor4D<DCHW, CT>({{depth, detail::ChannelToCount<CC>() * width * height},
                                      {detail::ChannelToCount<CC>(), width * height},
                                      {height, width},
                                      {width, 1}},
                                     isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, bool isCPU = true)
        : detail::Tensor4D<DCHW, CT>(
              {{depth, channelCount * width * height}, {channelCount, width * height}, {height, width}, {width, 1}},
              isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor4D<DCHW, CT>({{depth, detail::ChannelToCount<CC>() * width * height},
                                      {detail::ChannelToCount<CC>(), width * height},
                                      {height, width},
                                      {width, 1}},
                                     dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T != CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t rowPitch, DataType *dataPtr,
           B isCPU = true)
        : detail::Tensor4D<DCHW, CT>({{depth, detail::ChannelToCount<CC>() * height * rowPitch / GetChannelSize(CT)},
                                      {detail::ChannelToCount<CC>(), height * rowPitch / GetChannelSize(CT)},
                                      {height, rowPitch / GetChannelSize(CT)},
                                      {width, 1}},
                                     dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<DCHW, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, DataType *dataPtr,
           bool isCPU = true)
        : detail::Tensor4D<DCHW, CT>(
              {{depth, channelCount * width * height}, {channelCount, width * height}, {height, width}, {width, 1}},
              dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename B = bool,
             typename std::enable_if<T == CX && std::is_same<B, bool>::value>::type * = nullptr>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, std::size_t rowPitch,
           DataType *dataPtr, B isCPU = true)
        : detail::Tensor4D<DCHW, CT>({{depth, channelCount * height * rowPitch / GetChannelSize(CT)},
                                      {channelCount, height * rowPitch / GetChannelSize(CT)},
                                      {height, rowPitch / GetChannelSize(CT)},
                                      {width, 1}},
                                     dataPtr, isCPU)
    {
        if (rowPitch % GetChannelSize(CT) != 0)
        {
            throw std::domain_error(
                "cvcore::Tensor<DCHW, CC, CT>::Tensor ==> Parameter rowPitch is not evenly divisible by channel size");
        }
    }
};
 
template<ChannelCount CC, ChannelType CT>
class Tensor<CDHW, CC, CT> : public detail::Tensor4D<CDHW, CT>
{
public:
    using DataType = typename detail::ChannelTypeToNative<CT>::Type;
 
    static constexpr ChannelCount kChannelCount = CC;
 
    Tensor() = default;
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, bool isCPU = true)
        : detail::Tensor4D<CDHW, CT>({{detail::ChannelToCount<CC>(), depth * width * height},
                                      {depth, width * height},
                                      {height, width},
                                      {width, 1}},
                                     isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, bool isCPU = true)
        : detail::Tensor4D<CDHW, CT>(
              {{channelCount, depth * width * height}, {depth, width * height}, {height, width}, {width, 1}}, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T != CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, DataType *dataPtr, bool isCPU = true)
        : detail::Tensor4D<CDHW, CT>({{detail::ChannelToCount<CC>(), depth * width * height},
                                      {depth, width * height},
                                      {height, width},
                                      {width, 1}},
                                     dataPtr, isCPU)
    {
    }
 
    template<ChannelCount T = CC, typename = typename std::enable_if<T == CX>::type>
    Tensor(std::size_t width, std::size_t height, std::size_t depth, std::size_t channelCount, DataType *dataPtr,
           bool isCPU = true)
        : detail::Tensor4D<CDHW, CT>(
              {{channelCount, depth * width * height}, {depth, width * height}, {height, width}, {width, 1}}, dataPtr,
              isCPU)
    {
    }
};
 
} // namespace cvcore
 
#endif // CVCORE_TENSOR_H