Function scale_image

tests/validation/reference/CropResize.cpp:38–129

namespace
{
SimpleTensor<float> scale_image(const SimpleTensor<float> &in,
                                const TensorShape         &out_shape,
                                InterpolationPolicy        policy,
                                float                      extrapolation_value)
{
    ARM_COMPUTE_ERROR_ON(in.data_layout() != DataLayout::NHWC);

    SimpleTensor<float> out{out_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC};
    // Compute the ratio between source width/height and destination width/height
    const auto wr = static_cast<float>(in.shape()[1]) / static_cast<float>(out_shape[1]);
    const auto hr = static_cast<float>(in.shape()[2]) / static_cast<float>(out_shape[2]);

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

    Window win;
    win.use_tensor_dimensions(out_shape);
    execute_window_loop(
        win,
        [&](const Coordinates &out_id)
        {
            Coordinates in_id(out_id);
            int         idw = in_id.y();
            int         idh = in_id.z();

            switch (policy)
            {
                case InterpolationPolicy::NEAREST_NEIGHBOR:
                {
                    //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
                    float x_src = std::floor(idw * wr);
                    float y_src = std::floor(idh * hr);
                    in_id.set(1, x_src);
                    in_id.set(2, y_src);

                    // If coordinates in range of tensor's width or height
                    if (is_valid_pixel_index(x_src, y_src, width, height, 0))
                    {
                        *reinterpret_cast<float *>(out(out_id)) =
                            tensor_elem_at(in, in_id, BorderMode::CONSTANT, extrapolation_value);
                    }
                    else
                    {
                        *reinterpret_cast<float *>(out(out_id)) = extrapolation_value;
                    }
                    break;
                }
                case InterpolationPolicy::BILINEAR:
                {
                    float x_src = idw * wr;
                    float y_src = idh * hr;
                    in_id.set(1, std::floor(x_src));
                    in_id.set(2, std::floor(y_src));
                    if (is_valid_pixel_index(x_src, y_src, width, height, 0))
                    {
                        const int id_w = in_id[1];
                        const int id_h = in_id[2];