Compute Library
 20.05
Scale.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2020 ARM Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 
25 #include "Scale.h"
26 
27 #include "Utils.h"
29 
30 namespace arm_compute
31 {
32 namespace test
33 {
34 namespace validation
35 {
36 namespace reference
37 {
38 template <typename T>
39 SimpleTensor<T> scale_core(const SimpleTensor<T> &in, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value,
40  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
41 {
42  // Add 1 if ceil_policy_scale is true
43  const size_t round_value = ceil_policy_scale ? 1U : 0U;
44  TensorShape shape_scaled(in.shape());
45  shape_scaled.set(0, (in.shape()[0] + round_value) * scale_x);
46  shape_scaled.set(1, (in.shape()[1] + round_value) * scale_y);
47  SimpleTensor<T> out(shape_scaled, in.data_type());
48 
49  const auto needs_align_corners = policy == InterpolationPolicy::BILINEAR
50  && sampling_policy == SamplingPolicy::TOP_LEFT
51  && align_corners;
52 
53  // Compute the ratio between source width/height and destination width/height
54  const auto wr = arm_compute::calculate_resize_ratio(in.shape()[0], out.shape()[0], needs_align_corners);
55  const auto hr = arm_compute::calculate_resize_ratio(in.shape()[1], out.shape()[1], needs_align_corners);
56 
57  const auto width = static_cast<int>(in.shape().x());
58  const auto height = static_cast<int>(in.shape().y());
59 
60  // Determine border size
61  const int border_size = (border_mode == BorderMode::UNDEFINED) ? 0 : 1;
62 
63  // Area interpolation behaves as Nearest Neighbour in case of up-sampling
64  if(policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f)
65  {
67  }
68 
69  const uint32_t num_elements = out.num_elements();
70  for(uint32_t element_idx = 0, count = 0; element_idx < num_elements; ++element_idx, ++count)
71  {
72  Coordinates id = index2coord(out.shape(), element_idx);
73  int idx = id.x();
74  int idy = id.y();
75  float x_src = 0;
76  float y_src = 0;
77 
78  switch(policy)
79  {
81  {
82  switch(sampling_policy)
83  {
85  x_src = std::floor(idx * wr);
86  y_src = std::floor(idy * hr);
87  break;
89  //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
90  x_src = (idx + 0.5f) * wr;
91  y_src = (idy + 0.5f) * hr;
92  break;
93  default:
94  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
95  }
96 
97  id.set(0, x_src);
98  id.set(1, y_src);
99 
100  // If coordinates in range of tensor's width or height
101  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
102  {
103  out[element_idx] = tensor_elem_at(in, id, border_mode, constant_border_value);
104  }
105  break;
106  }
108  {
109  switch(sampling_policy)
110  {
112  x_src = idx * wr;
113  y_src = idy * hr;
114  break;
116  x_src = (idx + 0.5f) * wr - 0.5f;
117  y_src = (idy + 0.5f) * hr - 0.5f;
118  break;
119  default:
120  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
121  }
122 
123  id.set(0, std::floor(x_src));
124  id.set(1, std::floor(y_src));
125  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
126  {
127  out[element_idx] = bilinear_policy(in, id, x_src, y_src, border_mode, constant_border_value);
128  }
129  else
130  {
132  {
133  out[element_idx] = constant_border_value;
134  }
136  {
137  id.set(0, utility::clamp<int>(x_src, 0, width - 1));
138  id.set(1, utility::clamp<int>(y_src, 0, height - 1));
139  out[element_idx] = in[coord2index(in.shape(), id)];
140  }
141  }
142  break;
143  }
145  {
146  int x_from = std::floor(idx * wr - 0.5f - x_src);
147  int y_from = std::floor(idy * hr - 0.5f - y_src);
148  int x_to = std::ceil((idx + 1) * wr - 0.5f - x_src);
149  int y_to = std::ceil((idy + 1) * hr - 0.5f - y_src);
150  const int xi = std::floor(x_src);
151  const int yi = std::floor(y_src);
152 
153  // Clamp position to borders
154  x_src = std::max(-static_cast<float>(border_size), std::min(x_src, static_cast<float>(width - 1 + border_size)));
155  y_src = std::max(-static_cast<float>(border_size), std::min(y_src, static_cast<float>(height - 1 + border_size)));
156 
157  // Clamp bounding box offsets to borders
158  x_from = ((x_src + x_from) < -border_size) ? -border_size : x_from;
159  y_from = ((y_src + y_from) < -border_size) ? -border_size : y_from;
160  x_to = ((x_src + x_to) >= (width + border_size)) ? (width - 1 + border_size) : x_to;
161  y_to = ((y_src + y_to) >= (height + border_size)) ? (height - 1 + border_size) : y_to;
162  ARM_COMPUTE_ERROR_ON((x_to - x_from + 1) == 0 || (y_to - y_from + 1) == 0);
163 
164  float sum = 0;
165  for(int j = yi + y_from, je = yi + y_to; j <= je; ++j)
166  {
167  for(int i = xi + x_from, ie = xi + x_to; i <= ie; ++i)
168  {
169  id.set(0, static_cast<int>(i));
170  id.set(1, static_cast<int>(j));
171  sum += tensor_elem_at(in, id, border_mode, constant_border_value);
172  }
173  }
174  out[element_idx] = sum / ((x_to - x_from + 1) * (y_to - y_from + 1));
175 
176  break;
177  }
178  default:
179  ARM_COMPUTE_ERROR("Unsupported interpolation mode");
180  }
181  }
182 
183  return out;
184 }
185 
186 template <typename T>
187 SimpleTensor<T> scale(const SimpleTensor<T> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value,
188  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
189 {
190  return scale_core<T>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
191 }
192 
193 template <>
194 SimpleTensor<uint8_t> scale(const SimpleTensor<uint8_t> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, uint8_t constant_border_value,
195  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
196 {
198  if(src.quantization_info().uniform().scale != 0.f)
199  {
201  float constant_border_value_f = dequantize_qasymm8(constant_border_value, src.quantization_info());
202  SimpleTensor<float> dst_tmp = scale_core<float>(src_tmp, scale_x, scale_y, policy, border_mode, constant_border_value_f, sampling_policy, ceil_policy_scale, align_corners);
203  dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info());
204  }
205  else
206  {
207  dst = scale_core<uint8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
208  }
209  return dst;
210 }
211 
212 template <>
213 SimpleTensor<int8_t> scale(const SimpleTensor<int8_t> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, int8_t constant_border_value,
214  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
215 {
217  if(src.quantization_info().uniform().scale != 0.f)
218  {
220  float constant_border_value_f = dequantize_qasymm8_signed(constant_border_value, src.quantization_info());
221  SimpleTensor<float> dst_tmp = scale_core<float>(src_tmp, scale_x, scale_y, policy, border_mode, constant_border_value_f, sampling_policy, ceil_policy_scale, align_corners);
222  dst = convert_to_asymmetric<int8_t>(dst_tmp, src.quantization_info());
223  }
224  else
225  {
226  dst = scale_core<int8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
227  }
228  return dst;
229 }
230 
231 template SimpleTensor<int16_t> scale(const SimpleTensor<int16_t> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, int16_t constant_border_value,
232  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
233 template SimpleTensor<half> scale(const SimpleTensor<half> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, half constant_border_value,
234  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
235 template SimpleTensor<float> scale(const SimpleTensor<float> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, float constant_border_value,
236  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
237 } // namespace reference
238 } // namespace validation
239 } // namespace test
240 } // namespace arm_compute
BorderMode
Methods available to handle borders.
Definition: Types.h:264
InterpolationPolicy
Interpolation method.
Definition: Types.h:369
T tensor_elem_at(const SimpleTensor< T > &src, Coordinates coord, BorderMode border_mode, T constant_border_value)
Definition: Utils.h:61
Shape of a tensor.
Definition: TensorShape.h:39
float dequantize_qasymm8(uint8_t value, const INFO_TYPE &qinfo)
Dequantize a value given an unsigned 8-bit asymmetric quantization scheme.
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
DATA_TYPE sum(__global const DATA_TYPE *input)
Calculate sum of a vector.
half_float::half half
16-bit floating point type
Definition: Types.h:46
DataType data_type() const override
Data type of the tensor.
Definition: SimpleTensor.h:358
Output values are defined by bilinear interpolation between the pixels.
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
float calculate_resize_ratio(size_t input_size, size_t output_size, bool align_corners=false)
Returns resize ratio between input and output with consideration of aligned corners.
Definition: Utils.cpp:459
SimpleTensor< float > convert_from_asymmetric(const SimpleTensor< uint8_t > &src)
Definition: Helpers.cpp:112
TensorShape shape() const override
Shape of the tensor.
Definition: SimpleTensor.h:321
Output values are defined to match the source pixel whose center is nearest to the sample position.
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)
Definition: Scale.cpp:39
bool is_valid_pixel_index(int x, int y, int width, int height, int border_size)
Checks if a pixel has valid coordinates.
Definition: Utils.h:54
Copyright (c) 2017-2020 ARM Limited.
int coord2index(const TensorShape &shape, const Coordinates &coord)
Linearise the given coordinate.
Definition: Utils.h:489
Samples are taken at pixel center.
T x() const
Alias to access the size of the first dimension.
Definition: Dimensions.h:81
Coordinates of an item.
Definition: Coordinates.h:37
T bilinear_policy(const SimpleTensor< T > &in, Coordinates id, float xn, float yn, BorderMode border_mode, T constant_border_value)
Definition: Utils.cpp:36
Samples are taken at pixel top left corner.
Coordinates index2coord(const TensorShape &shape, int index)
Convert a linear index into n-dimensional coordinates.
Definition: Utils.h:460
Output values are determined by averaging the source pixels whose areas fall under the area of the de...
Simple tensor object that stores elements in a consecutive chunk of memory.
Definition: SimpleTensor.h:59
Borders are left undefined.
Pixels outside the image are assumed to have the same value as the closest image pixel.
float dequantize_qasymm8_signed(int8_t value, const INFO_TYPE &qinfo)
Dequantize a value given a signed 8-bit asymmetric quantization scheme.
TensorShape & set(size_t dimension, size_t value, bool apply_dim_correction=true)
Accessor to set the value of one of the dimensions.
Definition: TensorShape.h:78
SimpleTensor< T > scale(const SimpleTensor< T > &src, 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)
Definition: Scale.cpp:187
SamplingPolicy
Available Sampling Policies.
Definition: Types.h:102
cast configure & src
Definition: Cast.cpp:169