Function calculate_conv3d

tests/validation/reference/Conv3D.cpp:67–130

          typename std::enable_if<validation::is_floating_point<T>::value && validation::is_floating_point<TB>::value,
                                  int>::type = 0>
T calculate_conv3d(const SimpleTensor<T>  &src,
                   const SimpleTensor<T>  &weights,
                   const SimpleTensor<TB> &bias,
                   const Size3D           &dilation,
                   int                     batch,
                   int                     z_start,
                   int                     y_start,
                   int                     x_start,
                   int                     ch_out,
                   UniformQuantizationInfo oq_info)
{
    ARM_COMPUTE_UNUSED(oq_info);

    const unsigned int weights_width  = weights.shape()[weights_width_dim];
    const unsigned int weights_height = weights.shape()[weights_height_dim];
    const unsigned int weights_depth  = weights.shape()[weights_depth_dim];

    const unsigned int src_channels = src.shape()[channel_dim];
    const unsigned int src_width    = src.shape()[width_dim];
    const unsigned int src_height   = src.shape()[height_dim];
    const unsigned int src_depth    = src.shape()[depth_dim];

    TACC total(0);
    for (unsigned int weight_d = 0; weight_d < weights_depth; ++weight_d)
    {
        const int idx_z = z_start + dilation.depth * weight_d;
        for (unsigned int weight_y = 0; weight_y < weights_height; ++weight_y)
        {
            const int idx_y = y_start + dilation.height * weight_y;
            for (unsigned int weight_x = 0; weight_x < weights_width; ++weight_x)
            {
                const int idx_x = x_start + dilation.width * weight_x;

                //Check if the point is within padding
                const bool is_x_valid       = is_valid_pixel(idx_x, 0, src_width);
                const bool is_y_valid       = is_valid_pixel(idx_y, 0, src_height);
                const bool is_z_valid       = is_valid_pixel(idx_z, 0, src_depth);
                const bool is_invalid_pixel = !(is_x_valid && is_y_valid && is_z_valid);
                if (is_invalid_pixel)
                {
                    continue;
                }

                for (unsigned int ch_in = 0; ch_in < src_channels; ++ch_in)
                {
                    const T *in_ptr = src.data();
                    const T *w_ptr  = weights.data();

                    const int in_offset = coord2index(src.shape(), Coordinates{ch_in, idx_x, idx_y, idx_z, batch});
                    const int weight_offset =
                        coord2index(weights.shape(), Coordinates{ch_out, ch_in, weight_x, weight_y, weight_d});
                    T input_value  = in_ptr[in_offset];
                    T weight_value = w_ptr[weight_offset];
                    total += (input_value * weight_value);
                }
            }
        }
    }