Function scale_core

tests/validation/reference/Scale.cpp:41–193

{
template <typename T>
SimpleTensor<T> scale_core(const SimpleTensor<T> &in,
                           float                  scale_x,
                           float                  scale_y,
                           InterpolationPolicy    policy,
                           BorderMode             border_mode,
                           T                      constant_border_value,
                           SamplingPolicy         sampling_policy,
                           bool                   ceil_policy_scale,
                           bool                   align_corners)
{
    // Add 1 if ceil_policy_scale is true
    const size_t round_value = ceil_policy_scale ? 1U : 0U;
    TensorShape  shape_scaled(in.shape());
    shape_scaled.set(0, (in.shape()[0] + round_value) * scale_x, /* apply_dim_correction = */ false);
    shape_scaled.set(1, (in.shape()[1] + round_value) * scale_y, /* apply_dim_correction = */ false);
    SimpleTensor<T> out(shape_scaled, in.data_type());

    // Compute the ratio between source width/height and destination width/height
    const auto wr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[0], out.shape()[0], align_corners);
    const auto hr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[1], out.shape()[1], align_corners);

    const auto width  = static_cast<int>(in.shape().x());
    const auto height = static_cast<int>(in.shape().y());

    // Determine border size
    const int border_size = (border_mode == BorderMode::UNDEFINED) ? 0 : 1;

    // Area interpolation behaves as Nearest Neighbour in case of up-sampling
    if (policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f)
    {
        policy = InterpolationPolicy::NEAREST_NEIGHBOR;
    }

    const uint32_t num_elements = out.num_elements();
    for (uint32_t element_idx = 0, count = 0; element_idx < num_elements; ++element_idx, ++count)
    {
        Coordinates id    = index2coord(out.shape(), element_idx);
        int         idx   = id.x();
        int         idy   = id.y();
        float       x_src = 0;
        float       y_src = 0;

        switch (policy)
        {
            case InterpolationPolicy::NEAREST_NEIGHBOR:
            {
                switch (sampling_policy)
                {
                    case SamplingPolicy::TOP_LEFT:
                        x_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idx * wr)
                                              : std::floor(idx * wr);
                        y_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idy * hr)
                                              : std::floor(idy * hr);
                        break;
                    case SamplingPolicy::CENTER:
                        //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
                        x_src = (idx + 0.5f) * wr;
                        y_src = (idy + 0.5f) * hr;