Function pad_layer

tests/validation/reference/PadLayer.cpp:40–155

{
template <typename T>
SimpleTensor<T>
pad_layer(const SimpleTensor<T> &src, const PaddingList &paddings, const PixelValue const_value, const PaddingMode mode)
{
    const DataType dst_data_type = src.data_type();

    const TensorShape orig_shape = src.shape();

    std::vector<PaddingInfo> paddings_extended = paddings;

    for (size_t i = paddings.size(); i < TensorShape::num_max_dimensions; ++i)
    {
        paddings_extended.emplace_back(PaddingInfo{0, 0});
    }

    const TensorShape padded_shape = misc::shape_calculator::compute_padded_shape(orig_shape, paddings);

    SimpleTensor<T> dst(padded_shape, dst_data_type);

    // Reference algorithm: loop over the different dimension of the input.
    const uint32_t num_elements = dst.num_elements();
    for (uint32_t idx = 0; idx < num_elements; ++idx)
    {
        const Coordinates coord = index2coord(padded_shape, idx);

        const size_t i = coord.x();
        const size_t j = coord.y();
        const size_t k = coord.z();
        const size_t l = coord[3];
        const size_t m = coord[4];
        const size_t n = coord[5];

        const std::array<size_t, TensorShape::num_max_dimensions> dims            = {{0, 1, 2, 3, 4, 5}};
        const std::array<size_t, TensorShape::num_max_dimensions> coords          = {{i, j, k, l, m, n}};
        auto                                                      is_padding_area = [&](size_t i) {
            return (coords[i] < paddings_extended[i].first ||
                    coords[i] > orig_shape[i] + paddings_extended[i].first - 1);
        };

        auto orig_coord_reflect = [&](size_t i)
        {
            if (is_padding_area(i))
            {
                if (coords[i] < paddings_extended[i].first)
                {
                    return paddings_extended[i].first - coords[i];
                }
                else
                {
                    return 2 * orig_shape[i] + paddings_extended[i].first - 2 - coords[i];
                }
            }
            return coords[i] - paddings_extended[i].first;
        };

        auto orig_coord_symm = [&](size_t i)
        {
            if (is_padding_area(i))
            {