Compute Library
 22.11
Scale.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2020, 2022 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 #include "support/Rounding.h"
30 
31 namespace arm_compute
32 {
33 namespace test
34 {
35 namespace validation
36 {
37 namespace reference
38 {
39 template <typename T>
40 SimpleTensor<T> scale_core(const SimpleTensor<T> &in, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value,
41  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
42 {
43  // Add 1 if ceil_policy_scale is true
44  const size_t round_value = ceil_policy_scale ? 1U : 0U;
46  shape_scaled.set(0, (in.shape()[0] + round_value) * scale_x, /* apply_dim_correction = */ false);
47  shape_scaled.set(1, (in.shape()[1] + round_value) * scale_y, /* apply_dim_correction = */ false);
49 
50  // Compute the ratio between source width/height and destination width/height
51  const auto wr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[0], out.shape()[0], align_corners);
52  const auto hr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[1], out.shape()[1], align_corners);
53 
54  const auto width = static_cast<int>(in.shape().x());
55  const auto height = static_cast<int>(in.shape().y());
56 
57  // Determine border size
58  const int border_size = (border_mode == BorderMode::UNDEFINED) ? 0 : 1;
59 
60  // Area interpolation behaves as Nearest Neighbour in case of up-sampling
61  if(policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f)
62  {
64  }
65 
66  const uint32_t num_elements = out.num_elements();
67  for(uint32_t element_idx = 0, count = 0; element_idx < num_elements; ++element_idx, ++count)
68  {
69  Coordinates id = index2coord(out.shape(), element_idx);
70  int idx = id.x();
71  int idy = id.y();
72  float x_src = 0;
73  float y_src = 0;
74 
75  switch(policy)
76  {
78  {
79  switch(sampling_policy)
80  {
82  x_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idx * wr) : std::floor(idx * wr);
83  y_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idy * hr) : std::floor(idy * hr);
84  break;
86  //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
87  x_src = (idx + 0.5f) * wr;
88  y_src = (idy + 0.5f) * hr;
89  break;
90  default:
91  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
92  }
93 
94  id.set(0, x_src);
95  id.set(1, y_src);
96 
97  // If coordinates in range of tensor's width or height
98  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
99  {
100  out[element_idx] = tensor_elem_at(in, id, border_mode, constant_border_value);
101  }
102  break;
103  }
105  {
106  switch(sampling_policy)
107  {
109  x_src = idx * wr;
110  y_src = idy * hr;
111  break;
113  x_src = (idx + 0.5f) * wr - 0.5f;
114  y_src = (idy + 0.5f) * hr - 0.5f;
115  break;
116  default:
117  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
118  }
119 
120  id.set(0, std::floor(x_src));
121  id.set(1, std::floor(y_src));
122  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
123  {
124  out[element_idx] = bilinear_policy(in, id, x_src, y_src, border_mode, constant_border_value);
125  }
126  else
127  {
128  if(border_mode == BorderMode::CONSTANT)
129  {
130  out[element_idx] = constant_border_value;
131  }
132  else if(border_mode == BorderMode::REPLICATE)
133  {
134  id.set(0, utility::clamp<int>(x_src, 0, width - 1));
135  id.set(1, utility::clamp<int>(y_src, 0, height - 1));
136  out[element_idx] = in[coord2index(in.shape(), id)];
137  }
138  }
139  break;
140  }
142  {
143  int x_from = std::floor(idx * wr - 0.5f - x_src);
144  int y_from = std::floor(idy * hr - 0.5f - y_src);
145  int x_to = std::ceil((idx + 1) * wr - 0.5f - x_src);
146  int y_to = std::ceil((idy + 1) * hr - 0.5f - y_src);
147  const int xi = std::floor(x_src);
148  const int yi = std::floor(y_src);
149 
150  // Clamp position to borders
151  x_src = std::max(-static_cast<float>(border_size), std::min(x_src, static_cast<float>(width - 1 + border_size)));
152  y_src = std::max(-static_cast<float>(border_size), std::min(y_src, static_cast<float>(height - 1 + border_size)));
153 
154  // Clamp bounding box offsets to borders
155  x_from = ((x_src + x_from) < -border_size) ? -border_size : x_from;
156  y_from = ((y_src + y_from) < -border_size) ? -border_size : y_from;
157  x_to = ((x_src + x_to) >= (width + border_size)) ? (width - 1 + border_size) : x_to;
158  y_to = ((y_src + y_to) >= (height + border_size)) ? (height - 1 + border_size) : y_to;
159  ARM_COMPUTE_ERROR_ON((x_to - x_from + 1) == 0 || (y_to - y_from + 1) == 0);
160 
161  float sum = 0;
162  for(int j = yi + y_from, je = yi + y_to; j <= je; ++j)
163  {
164  for(int i = xi + x_from, ie = xi + x_to; i <= ie; ++i)
165  {
166  id.set(0, static_cast<int>(i));
167  id.set(1, static_cast<int>(j));
168  sum += tensor_elem_at(in, id, border_mode, constant_border_value);
169  }
170  }
171  out[element_idx] = sum / ((x_to - x_from + 1) * (y_to - y_from + 1));
172 
173  break;
174  }
175  default:
176  ARM_COMPUTE_ERROR("Unsupported interpolation mode");
177  }
178  }
179 
180  return out;
181 }
182 
183 template <typename T>
184 SimpleTensor<T> scale(const SimpleTensor<T> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value,
185  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
186 {
187  ARM_COMPUTE_UNUSED(output_quantization_info);
188  return scale_core<T>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
189 }
190 
191 template <>
192 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,
193  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
194 {
196  if(src.quantization_info().uniform().scale != 0.f)
197  {
199  float constant_border_value_f = dequantize_qasymm8(constant_border_value, src.quantization_info());
200  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);
201  dst = convert_to_asymmetric<uint8_t>(dst_tmp, output_quantization_info);
202  }
203  else
204  {
205  dst = scale_core<uint8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
206  }
207  return dst;
208 }
209 
210 template <>
211 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,
212  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
213 {
215  if(src.quantization_info().uniform().scale != 0.f)
216  {
218  float constant_border_value_f = dequantize_qasymm8_signed(constant_border_value, src.quantization_info());
219  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);
220  dst = convert_to_asymmetric<int8_t>(dst_tmp, output_quantization_info);
221  }
222  else
223  {
224  dst = scale_core<int8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
225  }
226  return dst;
227 }
228 
229 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,
230  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info);
231 template SimpleTensor<half> scale(const SimpleTensor<half> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, half constant_border_value,
232  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info);
233 template SimpleTensor<float> scale(const SimpleTensor<float> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, float constant_border_value,
234  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info);
235 } // namespace reference
236 } // namespace validation
237 } // namespace test
238 } // namespace arm_compute
BorderMode
Methods available to handle borders.
Definition: Types.h:274
InterpolationPolicy
Interpolation method.
Definition: Types.h:411
T tensor_elem_at(const SimpleTensor< T > &src, Coordinates coord, BorderMode border_mode, T constant_border_value)
Definition: Utils.h:63
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.
TensorShape shape_scaled(shape)
#define ARM_COMPUTE_ERROR(msg)
Print the given message then throw an std::runtime_error.
Definition: Error.h:352
half_float::half half
16-bit floating point type
Definition: Types.h:48
DataType data_type() const override
Data type of the tensor.
Definition: SimpleTensor.h:357
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
SimpleTensor< float > convert_from_asymmetric(const SimpleTensor< uint8_t > &src)
Definition: Helpers.cpp:36
TensorShape shape() const override
Shape of the tensor.
Definition: SimpleTensor.h:320
T round_half_away_from_zero(T value)
Round floating-point value with half value rounding away from zero.
Definition: Rounding.h:106
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:40
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:53
SimpleTensor< float > src
Definition: DFT.cpp:155
Copyright (c) 2017-2022 Arm Limited.
int coord2index(const TensorShape &shape, const Coordinates &coord)
Linearise the given coordinate.
Definition: Utils.h:388
Samples are taken at pixel center.
T x() const
Alias to access the size of the first dimension.
Definition: Dimensions.h:87
Quantization information.
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
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, QuantizationInfo output_quantization_info)
Definition: Scale.cpp:184
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
UniformQuantizationInfo uniform() const
Return per layer quantization info.
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:359
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:58
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.
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: ScaleUtils.cpp:31
QuantizationInfo quantization_info() const override
Quantization info in case of asymmetric quantized type.
Definition: SimpleTensor.h:332
TensorShape & set(size_t dimension, size_t value, bool apply_dim_correction=true, bool increase_dim_unit=true)
Accessor to set the value of one of the dimensions.
Definition: TensorShape.h:79
SamplingPolicy
Available Sampling Policies.
Definition: Types.h:104