pad.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#ifndef HIPIPE_CORE_STREAM_PAD_HPP
#define HIPIPE_CORE_STREAM_PAD_HPP
 
#include <hipipe/core/stream/transform.hpp>
#include <hipipe/core/utility/ndim.hpp>
 
namespace hipipe::stream {
namespace detail {
 
    // Create a transformation function that can be sent to stream::transform.
    template<typename FromColumn, typename MaskColumn, typename ValT>
    struct wrap_pad_fun_for_transform {
        ValT value;
 
        std::tuple<typename FromColumn::data_type, typename MaskColumn::data_type>
        operator()(typename FromColumn::data_type& source)
        {
            using SourceVector = typename FromColumn::data_type;
            using MaskVector = typename MaskColumn::data_type;
            constexpr long SourceDims = utility::ndims<SourceVector>::value;
            constexpr long MaskDims = utility::ndims<MaskVector>::value;
            static_assert(MaskDims <= SourceDims, "stream::pad requires"
              " the number of padded dimensions (i.e., the number of dimensions"
              " of the mask) to be at most the number of dimensions of the source column.");
            // create the positive mask
            std::vector<std::vector<long>> source_size = utility::ndim_size<MaskDims>(source);
            MaskVector mask;
            utility::ndim_resize<MaskDims>(mask, source_size, true);
            // pad the source
            utility::ndim_pad<MaskDims>(source, value);
            // create the negative mask
            source_size = utility::ndim_size<MaskDims>(source);
            utility::ndim_resize<MaskDims>(mask, source_size, false);
            return {std::move(source), std::move(mask)};
        }
    };
 
}  // namespace detail
 
template<
  typename FromColumn, typename MaskColumn,
  // The value type is automatically deduced as the type of the source column
  // in the dimension of the mask column.
  typename ValT =
    typename utility::ndim_type_t<
      typename FromColumn::data_type,
      utility::ndims<typename MaskColumn::data_type>::value>>
auto pad(from_t<FromColumn> f, mask_t<MaskColumn> m, ValT value = ValT{})
{
    detail::wrap_pad_fun_for_transform<FromColumn, MaskColumn, ValT>
      trans_fun{std::move(value)};
    return stream::transform(from<FromColumn>, to<FromColumn, MaskColumn>,
                             std::move(trans_fun), dim<0>);
}
 
}  // namespace hipipe::stream
#endif