Compute Library
 20.02.1
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"
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;
45  TensorShape shape_scaled(in.shape());
46  shape_scaled.set(0, (in.shape()[0] + round_value) * scale_x);
47  shape_scaled.set(1, (in.shape()[1] + round_value) * scale_y);
48  SimpleTensor<T> out(shape_scaled, in.data_type());
49 
50  const auto needs_align_corners = policy == InterpolationPolicy::BILINEAR
51  && sampling_policy == SamplingPolicy::TOP_LEFT
52  && align_corners;
53 
54  // Compute the ratio between source width/height and destination width/height
55  const auto wr = arm_compute::calculate_resize_ratio(in.shape()[0], out.shape()[0], needs_align_corners);
56  const auto hr = arm_compute::calculate_resize_ratio(in.shape()[1], out.shape()[1], needs_align_corners);
57 
58  const auto width = static_cast<int>(in.shape().x());
59  const auto height = static_cast<int>(in.shape().y());
60 
61  // Determine border size
62  const int border_size = (border_mode == BorderMode::UNDEFINED) ? 0 : 1;
63 
64  // Area interpolation behaves as Nearest Neighbour in case of up-sampling
65  if(policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f)
66  {
68  }
69 
70  const uint32_t num_elements = out.num_elements();
71  for(uint32_t element_idx = 0, count = 0; element_idx < num_elements; ++element_idx, ++count)
72  {
73  Coordinates id = index2coord(out.shape(), element_idx);
74  int idx = id.x();
75  int idy = id.y();
76  float x_src = 0;
77  float y_src = 0;
78 
79  switch(policy)
80  {
82  {
83  switch(sampling_policy)
84  {
86  x_src = std::floor(idx * wr);
87  y_src = std::floor(idy * hr);
88  break;
90  //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
91  x_src = (idx + 0.5f) * wr;
92  y_src = (idy + 0.5f) * hr;
93  break;
94  default:
95  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
96  }
97 
98  id.set(0, x_src);
99  id.set(1, y_src);
100 
101  // If coordinates in range of tensor's width or height
102  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
103  {
104  out[element_idx] = tensor_elem_at(in, id, border_mode, constant_border_value);
105  }
106  break;
107  }
109  {
110  switch(sampling_policy)
111  {
113  x_src = idx * wr;
114  y_src = idy * hr;
115  break;
117  x_src = (idx + 0.5f) * wr - 0.5f;
118  y_src = (idy + 0.5f) * hr - 0.5f;
119  break;
120  default:
121  ARM_COMPUTE_ERROR("Unsupported sampling policy.");
122  }
123 
124  id.set(0, std::floor(x_src));
125  id.set(1, std::floor(y_src));
126  if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
127  {
128  out[element_idx] = bilinear_policy(in, id, x_src, y_src, border_mode, constant_border_value);
129  }
130  else
131  {
133  {
134  out[element_idx] = constant_border_value;
135  }
137  {
138  id.set(0, utility::clamp<int>(x_src, 0, width - 1));
139  id.set(1, utility::clamp<int>(y_src, 0, height - 1));
140  out[element_idx] = in[coord2index(in.shape(), id)];
141  }
142  }
143  break;
144  }
146  {
147  int x_from = std::floor(idx * wr - 0.5f - x_src);
148  int y_from = std::floor(idy * hr - 0.5f - y_src);
149  int x_to = std::ceil((idx + 1) * wr - 0.5f - x_src);
150  int y_to = std::ceil((idy + 1) * hr - 0.5f - y_src);
151  const int xi = std::floor(x_src);
152  const int yi = std::floor(y_src);
153 
154  // Clamp position to borders
155  x_src = std::max(-static_cast<float>(border_size), std::min(x_src, static_cast<float>(width - 1 + border_size)));
156  y_src = std::max(-static_cast<float>(border_size), std::min(y_src, static_cast<float>(height - 1 + border_size)));
157 
158  // Clamp bounding box offsets to borders
159  x_from = ((x_src + x_from) < -border_size) ? -border_size : x_from;
160  y_from = ((y_src + y_from) < -border_size) ? -border_size : y_from;
161  x_to = ((x_src + x_to) >= (width + border_size)) ? (width - 1 + border_size) : x_to;
162  y_to = ((y_src + y_to) >= (height + border_size)) ? (height - 1 + border_size) : y_to;
163  ARM_COMPUTE_ERROR_ON((x_to - x_from + 1) == 0 || (y_to - y_from + 1) == 0);
164 
165  float sum = 0;
166  for(int j = yi + y_from, je = yi + y_to; j <= je; ++j)
167  {
168  for(int i = xi + x_from, ie = xi + x_to; i <= ie; ++i)
169  {
170  id.set(0, static_cast<int>(i));
171  id.set(1, static_cast<int>(j));
172  sum += tensor_elem_at(in, id, border_mode, constant_border_value);
173  }
174  }
175  out[element_idx] = sum / ((x_to - x_from + 1) * (y_to - y_from + 1));
176 
177  break;
178  }
179  default:
180  ARM_COMPUTE_ERROR("Unsupported interpolation mode");
181  }
182  }
183 
184  return out;
185 }
186 
187 template <typename T>
188 SimpleTensor<T> scale(const SimpleTensor<T> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value,
189  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
190 {
191  return scale_core<T>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
192 }
193 
194 template <>
195 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,
196  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
197 {
199  if(src.quantization_info().uniform().scale != 0.f)
200  {
202  float constant_border_value_f = dequantize_qasymm8(constant_border_value, src.quantization_info());
203  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);
204  dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info());
205  }
206  else
207  {
208  dst = scale_core<uint8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
209  }
210  return dst;
211 }
212 
213 template <>
214 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,
215  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
216 {
218  if(src.quantization_info().uniform().scale != 0.f)
219  {
221  float constant_border_value_f = dequantize_qasymm8_signed(constant_border_value, src.quantization_info());
222  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);
223  dst = convert_to_asymmetric<int8_t>(dst_tmp, src.quantization_info());
224  }
225  else
226  {
227  dst = scale_core<int8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
228  }
229  return dst;
230 }
231 
232 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,
233  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
234 template SimpleTensor<half> scale(const SimpleTensor<half> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, half constant_border_value,
235  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
236 template SimpleTensor<float> scale(const SimpleTensor<float> &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, float constant_border_value,
237  SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners);
238 } // namespace reference
239 } // namespace validation
240 } // namespace test
241 } // namespace arm_compute
BorderMode
Methods available to handle borders.
Definition: Types.h:261
InterpolationPolicy
Interpolation method.
Definition: Types.h:366
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:45
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:466
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: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:54
Copyright (c) 2017-2020 ARM Limited.
int coord2index(const TensorShape &shape, const Coordinates &coord)
Linearise the given coordinate.
Definition: Utils.h:485
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:456
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:188
SamplingPolicy
Available Sampling Policies.
Definition: Types.h:99
cast configure & src
Definition: Cast.cpp:169