From 970f43b078eba91c66fb64eadbc9803661ffcda8 Mon Sep 17 00:00:00 2001 From: Teresa Charlin Date: Mon, 1 Jul 2019 13:51:07 +0100 Subject: IVGCVSW-3365 Add reference workload support for ResizeLayer Signed-off-by: Teresa Charlin Change-Id: Id551690065dca0686ce597d1f0c14fd73163481e --- src/backends/reference/workloads/Resize.cpp | 130 ++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 src/backends/reference/workloads/Resize.cpp (limited to 'src/backends/reference/workloads/Resize.cpp') diff --git a/src/backends/reference/workloads/Resize.cpp b/src/backends/reference/workloads/Resize.cpp new file mode 100644 index 0000000000..0e0bdd7597 --- /dev/null +++ b/src/backends/reference/workloads/Resize.cpp @@ -0,0 +1,130 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "Resize.hpp" + +#include "TensorBufferArrayView.hpp" + +#include + +#include +#include + +using namespace armnnUtils; + +namespace armnn +{ + +namespace +{ + +inline float Lerp(float a, float b, float w) +{ + return w * b + (1.f - w) * a; +} + +}// anonymous namespace + +void Resize(Decoder& in, + const TensorInfo& inputInfo, + Encoder& out, + const TensorInfo& outputInfo, + DataLayoutIndexed dataLayout, + armnn::ResizeMethod resizeMethod) +{ + // We follow the definition of TensorFlow and AndroidNN: the top-left corner of a texel in the output + // image is projected into the input image to figure out the interpolants and weights. Note that this + // will yield different results than if projecting the centre of output texels. + + const unsigned int batchSize = inputInfo.GetShape()[0]; + const unsigned int channelCount = inputInfo.GetShape()[dataLayout.GetChannelsIndex()]; + + const unsigned int inputHeight = inputInfo.GetShape()[dataLayout.GetHeightIndex()]; + const unsigned int inputWidth = inputInfo.GetShape()[dataLayout.GetWidthIndex()]; + const unsigned int outputHeight = outputInfo.GetShape()[dataLayout.GetHeightIndex()]; + const unsigned int outputWidth = outputInfo.GetShape()[dataLayout.GetWidthIndex()]; + + // How much to scale pixel coordinates in the output image, to get the corresponding pixel coordinates + // in the input image. + const float scaleY = boost::numeric_cast(inputHeight) / boost::numeric_cast(outputHeight); + const float scaleX = boost::numeric_cast(inputWidth) / boost::numeric_cast(outputWidth); + + TensorShape inputShape = inputInfo.GetShape(); + TensorShape outputShape = outputInfo.GetShape(); + + for (unsigned int n = 0; n < batchSize; ++n) + { + for (unsigned int c = 0; c < channelCount; ++c) + { + for (unsigned int y = 0; y < outputHeight; ++y) + { + // Corresponding real-valued height coordinate in input image. + const float iy = boost::numeric_cast(y) * scaleY; + + // Discrete height coordinate of top-left texel (in the 2x2 texel area used for interpolation). + const float fiy = floorf(iy); + const unsigned int y0 = boost::numeric_cast(fiy); + + // Interpolation weight (range [0,1]). + const float yw = iy - fiy; + + for (unsigned int x = 0; x < outputWidth; ++x) + { + // Real-valued and discrete width coordinates in input image. + const float ix = boost::numeric_cast(x) * scaleX; + const float fix = floorf(ix); + const unsigned int x0 = boost::numeric_cast(fix); + + // Interpolation weight (range [0,1]). + const float xw = ix - fix; + + // Discrete width/height coordinates of texels below and to the right of (x0, y0). + const unsigned int x1 = std::min(x0 + 1, inputWidth - 1u); + const unsigned int y1 = std::min(y0 + 1, inputHeight - 1u); + + float interpolatedValue; + switch (resizeMethod) + { + case armnn::ResizeMethod::Bilinear: + { + in[dataLayout.GetIndex(inputShape, n, c, y0, x0)]; + float input1 = in.Get(); + in[dataLayout.GetIndex(inputShape, n, c, y0, x1)]; + float input2 = in.Get(); + in[dataLayout.GetIndex(inputShape, n, c, y1, x0)]; + float input3 = in.Get(); + in[dataLayout.GetIndex(inputShape, n, c, y1, x1)]; + float input4 = in.Get(); + + const float ly0 = Lerp(input1, input2, xw); // lerp along row y0. + const float ly1 = Lerp(input3, input4, xw); // lerp along row y1. + interpolatedValue = Lerp(ly0, ly1, yw); + break; + } + case armnn::ResizeMethod::NearestNeighbor: + default: + { + auto distance0 = std::sqrt(pow(fix - boost::numeric_cast(x0), 2) + + pow(fiy - boost::numeric_cast(y0), 2)); + auto distance1 = std::sqrt(pow(fix - boost::numeric_cast(x1), 2) + + pow(fiy - boost::numeric_cast(y1), 2)); + + unsigned int xNearest = distance0 <= distance1? x0 : x1; + unsigned int yNearest = distance0 <= distance1? y0 : y1; + + in[dataLayout.GetIndex(inputShape, n, c, yNearest, xNearest)]; + interpolatedValue = in.Get(); + break; + } + } + out[dataLayout.GetIndex(outputShape, n, c, y, x)]; + out.Set(interpolatedValue); + } + } + } + } +} + +} //namespace armnn -- cgit v1.2.1