blob: 3db8369f089e73fac79212953f6dd61cad64876b [file] [log] [blame]
Anthony Barbier6ff3b192017-09-04 18:44:23 +01001/*
Diego Lopez Recas0021d752017-12-18 14:42:56 +00002 * Copyright (c) 2016-2018 ARM Limited.
Anthony Barbier6ff3b192017-09-04 18:44:23 +01003 *
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#include "arm_compute/core/Error.h"
25#include "arm_compute/core/Validate.h"
26
27#include <cmath>
28#include <numeric>
29
30namespace arm_compute
31{
Anthony Barbier6ff3b192017-09-04 18:44:23 +010032inline uint8_t pixel_area_c1u8_clamp(const uint8_t *first_pixel_ptr, size_t stride, size_t width, size_t height, float wr, float hr, int x, int y)
33{
34 ARM_COMPUTE_ERROR_ON(first_pixel_ptr == nullptr);
35
36 // Calculate sampling position
37 float in_x = (x + 0.5f) * wr - 0.5f;
38 float in_y = (y + 0.5f) * hr - 0.5f;
39
40 // Get bounding box offsets
41 int x_from = std::floor(x * wr - 0.5f - in_x);
42 int y_from = std::floor(y * hr - 0.5f - in_y);
43 int x_to = std::ceil((x + 1) * wr - 0.5f - in_x);
44 int y_to = std::ceil((y + 1) * hr - 0.5f - in_y);
45
46 // Clamp position to borders
47 in_x = std::max(-1.f, std::min(in_x, static_cast<float>(width)));
48 in_y = std::max(-1.f, std::min(in_y, static_cast<float>(height)));
49
50 // Clamp bounding box offsets to borders
51 x_from = ((in_x + x_from) < -1) ? -1 : x_from;
52 y_from = ((in_y + y_from) < -1) ? -1 : y_from;
53 x_to = ((in_x + x_to) > width) ? (width - in_x) : x_to;
54 y_to = ((in_y + y_to) > height) ? (height - in_y) : y_to;
55
56 // Get pixel index
57 const int xi = std::floor(in_x);
58 const int yi = std::floor(in_y);
59
60 // Bounding box elements in each dimension
61 const int x_elements = (x_to - x_from + 1);
62 const int y_elements = (y_to - y_from + 1);
63 ARM_COMPUTE_ERROR_ON(x_elements == 0 || y_elements == 0);
64
65 // Sum pixels in area
66 int sum = 0;
67 for(int j = yi + y_from, je = yi + y_to; j <= je; ++j)
68 {
69 const uint8_t *ptr = first_pixel_ptr + j * stride + xi + x_from;
70 sum = std::accumulate(ptr, ptr + x_elements, sum);
71 }
72
73 // Return average
74 return sum / (x_elements * y_elements);
75}
76
77template <size_t dimension>
78struct IncrementIterators
79{
80 template <typename T, typename... Ts>
81 static void unroll(T &&it, Ts &&... iterators)
82 {
Diego Lopez Recas490b3d82017-12-19 15:42:25 +000083 auto increment = [](T && it)
84 {
85 it.increment(dimension);
86 };
87 utility::for_each(increment, std::forward<T>(it), std::forward<Ts>(iterators)...);
Anthony Barbier6ff3b192017-09-04 18:44:23 +010088 }
Anthony Barbier6ff3b192017-09-04 18:44:23 +010089 static void unroll()
90 {
91 // End of recursion
92 }
93};
94
95template <size_t dim>
96struct ForEachDimension
97{
98 template <typename L, typename... Ts>
99 static void unroll(const Window &w, Coordinates &id, L &&lambda_function, Ts &&... iterators)
100 {
101 const auto &d = w[dim - 1];
102
103 for(auto v = d.start(); v < d.end(); v += d.step(), IncrementIterators < dim - 1 >::unroll(iterators...))
104 {
105 id.set(dim - 1, v);
106 ForEachDimension < dim - 1 >::unroll(w, id, lambda_function, iterators...);
107 }
108 }
109};
110
111template <>
112struct ForEachDimension<0>
113{
114 template <typename L, typename... Ts>
115 static void unroll(const Window &w, Coordinates &id, L &&lambda_function, Ts &&... iterators)
116 {
117 lambda_function(id);
118 }
119};
120
121template <typename L, typename... Ts>
122inline void execute_window_loop(const Window &w, L &&lambda_function, Ts &&... iterators)
123{
124 w.validate();
125
Diego Lopez Recas0021d752017-12-18 14:42:56 +0000126 for(unsigned int i = 0; i < Coordinates::num_max_dimensions; ++i)
127 {
128 ARM_COMPUTE_ERROR_ON(w[i].step() == 0);
129 }
130
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100131 Coordinates id;
132 ForEachDimension<Coordinates::num_max_dimensions>::unroll(w, id, std::forward<L>(lambda_function), std::forward<Ts>(iterators)...);
133}
134
135inline constexpr Iterator::Iterator()
136 : _ptr(nullptr), _dims()
137{
138}
139
140inline Iterator::Iterator(const ITensor *tensor, const Window &win)
141 : Iterator()
142{
143 ARM_COMPUTE_ERROR_ON(tensor == nullptr);
Diego Lopez Recas0021d752017-12-18 14:42:56 +0000144 ARM_COMPUTE_ERROR_ON(tensor->info() == nullptr);
145
146 const ITensorInfo *info = tensor->info();
147 const Strides &strides = info->strides_in_bytes();
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100148
149 _ptr = tensor->buffer() + info->offset_first_element_in_bytes();
150
151 //Initialize the stride for each dimension and calculate the position of the first element of the iteration:
152 for(unsigned int n = 0; n < info->num_dimensions(); ++n)
153 {
154 _dims[n]._stride = win[n].step() * strides[n];
155 std::get<0>(_dims)._dim_start += strides[n] * win[n].start();
156 }
157
158 //Copy the starting point to all the dimensions:
159 for(unsigned int n = 1; n < Coordinates::num_max_dimensions; ++n)
160 {
161 _dims[n]._dim_start = std::get<0>(_dims)._dim_start;
162 }
163
164 ARM_COMPUTE_ERROR_ON_WINDOW_DIMENSIONS_GTE(win, info->num_dimensions());
165}
166
167inline void Iterator::increment(const size_t dimension)
168{
169 ARM_COMPUTE_ERROR_ON(dimension >= Coordinates::num_max_dimensions);
170
171 _dims[dimension]._dim_start += _dims[dimension]._stride;
172
173 for(unsigned int n = 0; n < dimension; ++n)
174 {
175 _dims[n]._dim_start = _dims[dimension]._dim_start;
176 }
177}
178
179inline constexpr int Iterator::offset() const
180{
181 return _dims.at(0)._dim_start;
182}
183
184inline constexpr uint8_t *Iterator::ptr() const
185{
186 return _ptr + _dims.at(0)._dim_start;
187}
188
189inline void Iterator::reset(const size_t dimension)
190{
191 ARM_COMPUTE_ERROR_ON(dimension >= Coordinates::num_max_dimensions - 1);
192
193 _dims[dimension]._dim_start = _dims[dimension + 1]._dim_start;
194
195 for(unsigned int n = 0; n < dimension; ++n)
196 {
197 _dims[n]._dim_start = _dims[dimension]._dim_start;
198 }
199}
200
Georgios Pinitas05078ec2017-11-02 13:06:59 +0000201inline bool auto_init_if_empty(ITensorInfo &info,
202 const TensorShape &shape,
203 int num_channels,
204 DataType data_type,
205 int fixed_point_position,
206 QuantizationInfo quantization_info)
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100207{
208 if(info.tensor_shape().total_size() == 0)
209 {
210 info.set_data_type(data_type);
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100211 info.set_num_channels(num_channels);
Gian Marco Iodice559d7712017-08-08 08:38:09 +0100212 info.set_tensor_shape(shape);
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100213 info.set_fixed_point_position(fixed_point_position);
Georgios Pinitas05078ec2017-11-02 13:06:59 +0000214 info.set_quantization_info(quantization_info);
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100215 return true;
216 }
217
218 return false;
219}
220
Pablo Palmiera2b89ca2017-10-05 15:01:34 +0100221inline bool auto_init_if_empty(ITensorInfo &info_sink, const ITensorInfo &info_source)
Georgios Pinitas283c1792017-11-10 18:14:06 +0000222{
223 if(info_sink.tensor_shape().total_size() == 0)
224 {
225 info_sink.set_data_type(info_source.data_type());
226 info_sink.set_num_channels(info_source.num_channels());
227 info_sink.set_tensor_shape(info_source.tensor_shape());
228 info_sink.set_fixed_point_position(info_source.fixed_point_position());
229 info_sink.set_quantization_info(info_source.quantization_info());
Isabella Gottardid17a6772018-02-27 17:41:55 +0000230 info_sink.set_data_layout(info_source.data_layout());
Georgios Pinitas283c1792017-11-10 18:14:06 +0000231 return true;
232 }
233
234 return false;
235}
236
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100237inline bool set_shape_if_empty(ITensorInfo &info, const TensorShape &shape)
238{
239 if(info.tensor_shape().total_size() == 0)
240 {
241 info.set_tensor_shape(shape);
242 return true;
243 }
244
245 return false;
246}
247
248inline bool set_format_if_unknown(ITensorInfo &info, Format format)
249{
250 if(info.data_type() == DataType::UNKNOWN)
251 {
252 info.set_format(format);
253 return true;
254 }
255
256 return false;
257}
258
259inline bool set_data_type_if_unknown(ITensorInfo &info, DataType data_type)
260{
261 if(info.data_type() == DataType::UNKNOWN)
262 {
263 info.set_data_type(data_type);
264 return true;
265 }
266
267 return false;
268}
269
Isabella Gottardid17a6772018-02-27 17:41:55 +0000270inline bool set_data_layout_if_unknown(ITensorInfo &info, DataLayout data_layout)
271{
272 if(info.data_layout() == DataLayout::UNKNOWN)
273 {
274 info.set_data_layout(data_layout);
275 return true;
276 }
277
278 return false;
279}
280
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100281inline bool set_fixed_point_position_if_zero(ITensorInfo &info, int fixed_point_position)
282{
283 if(info.fixed_point_position() == 0 && (info.data_type() == DataType::QS8 || info.data_type() == DataType::QS16))
284 {
285 info.set_fixed_point_position(fixed_point_position);
286 return true;
287 }
288
289 return false;
290}
Isabella Gottardi1fab09f2017-07-13 15:55:57 +0100291
Georgios Pinitas05078ec2017-11-02 13:06:59 +0000292inline bool set_quantization_info_if_empty(ITensorInfo &info, QuantizationInfo quantization_info)
293{
Anton Lokhmotovaf6204c2017-11-08 09:34:19 +0000294 if(info.quantization_info().empty() && (is_data_type_quantized_asymmetric(info.data_type())))
Georgios Pinitas05078ec2017-11-02 13:06:59 +0000295 {
296 info.set_quantization_info(quantization_info);
297 return true;
298 }
299
300 return false;
301}
302
Isabella Gottardi1fab09f2017-07-13 15:55:57 +0100303inline ValidRegion calculate_valid_region_scale(const ITensorInfo &src_info, const TensorShape &dst_shape, InterpolationPolicy policy, BorderSize border_size, bool border_undefined)
304{
Anthony Barbier77562dc2018-02-26 17:18:32 +0000305 const auto wr = static_cast<float>(dst_shape[0]) / static_cast<float>(src_info.tensor_shape()[0]);
306 const auto hr = static_cast<float>(dst_shape[1]) / static_cast<float>(src_info.tensor_shape()[1]);
Diego Lopez Recasbcbc9702017-12-18 11:28:27 +0000307
308 ValidRegion valid_region{ Coordinates(), dst_shape, src_info.tensor_shape().num_dimensions() };
309
Anthony Barbier77562dc2018-02-26 17:18:32 +0000310 Coordinates &anchor = valid_region.anchor;
311 TensorShape &shape = valid_region.shape;
Diego Lopez Recasbcbc9702017-12-18 11:28:27 +0000312
Anthony Barbier77562dc2018-02-26 17:18:32 +0000313 anchor.set(0, (policy == InterpolationPolicy::BILINEAR
314 && border_undefined) ?
315 ((static_cast<int>(src_info.valid_region().anchor[0]) + border_size.left + 0.5f) * wr - 0.5f) :
316 ((static_cast<int>(src_info.valid_region().anchor[0]) + 0.5f) * wr - 0.5f));
317 anchor.set(1, (policy == InterpolationPolicy::BILINEAR
318 && border_undefined) ?
319 ((static_cast<int>(src_info.valid_region().anchor[1]) + border_size.top + 0.5f) * hr - 0.5f) :
320 ((static_cast<int>(src_info.valid_region().anchor[1]) + 0.5f) * hr - 0.5f));
321 float shape_out_x = (policy == InterpolationPolicy::BILINEAR
322 && border_undefined) ?
323 ((static_cast<int>(src_info.valid_region().anchor[0]) + static_cast<int>(src_info.valid_region().shape[0]) - 1) - 1 + 0.5f) * wr - 0.5f :
324 ((static_cast<int>(src_info.valid_region().anchor[0]) + static_cast<int>(src_info.valid_region().shape[0])) + 0.5f) * wr - 0.5f;
325 float shape_out_y = (policy == InterpolationPolicy::BILINEAR
326 && border_undefined) ?
327 ((static_cast<int>(src_info.valid_region().anchor[1]) + static_cast<int>(src_info.valid_region().shape[1]) - 1) - 1 + 0.5f) * hr - 0.5f :
328 ((static_cast<int>(src_info.valid_region().anchor[1]) + static_cast<int>(src_info.valid_region().shape[1])) + 0.5f) * hr - 0.5f;
329
330 shape.set(0, shape_out_x - anchor[0]);
331 shape.set(1, shape_out_y - anchor[1]);
Isabella Gottardi1fab09f2017-07-13 15:55:57 +0100332
Diego Lopez Recasbcbc9702017-12-18 11:28:27 +0000333 return valid_region;
Isabella Gottardi1fab09f2017-07-13 15:55:57 +0100334}
Georgios Pinitas5ee66ea2017-09-07 17:29:16 +0100335
336inline Coordinates index2coords(const TensorShape &shape, int index)
337{
338 int num_elements = shape.total_size();
339
340 ARM_COMPUTE_ERROR_ON_MSG(index < 0 || index >= num_elements, "Index has to be in [0, num_elements]!");
341 ARM_COMPUTE_ERROR_ON_MSG(num_elements == 0, "Cannot create coordinate from empty shape!");
342
343 Coordinates coord{ 0 };
344
345 for(int d = shape.num_dimensions() - 1; d >= 0; --d)
346 {
347 num_elements /= shape[d];
348 coord.set(d, index / num_elements);
349 index %= num_elements;
350 }
351
352 return coord;
353}
354
355inline int coords2index(const TensorShape &shape, const Coordinates &coord)
356{
357 int num_elements = shape.total_size();
358 ARM_COMPUTE_UNUSED(num_elements);
359 ARM_COMPUTE_ERROR_ON_MSG(num_elements == 0, "Cannot create linear index from empty shape!");
360
361 int index = 0;
362 int stride = 1;
363
364 for(unsigned int d = 0; d < coord.num_dimensions(); ++d)
365 {
366 index += coord[d] * stride;
367 stride *= shape[d];
368 }
369
370 return index;
371}
Isabella Gottardid17a6772018-02-27 17:41:55 +0000372
Isabella Gottardid56e7702018-02-28 14:29:36 +0000373inline size_t get_data_layout_dimension_index(const DataLayout data_layout, const DataLayoutDimension data_layout_dimension)
Isabella Gottardid17a6772018-02-27 17:41:55 +0000374{
Isabella Gottardid56e7702018-02-28 14:29:36 +0000375 ARM_COMPUTE_ERROR_ON_MSG(data_layout == DataLayout::UNKNOWN, "Cannot retrieve the dimension index for an unknown layout!");
Isabella Gottardid17a6772018-02-27 17:41:55 +0000376
377 /* Return the index based on the data layout
378 * [N C H W]
379 * [3 2 1 0]
380 * [N H W C]
381 */
382 switch(data_layout_dimension)
383 {
384 case DataLayoutDimension::CHANNEL:
Isabella Gottardid56e7702018-02-28 14:29:36 +0000385 return (data_layout == DataLayout::NCHW) ? 2 : 0;
Isabella Gottardid17a6772018-02-27 17:41:55 +0000386 break;
387 case DataLayoutDimension::HEIGHT:
Isabella Gottardid56e7702018-02-28 14:29:36 +0000388 return (data_layout == DataLayout::NCHW) ? 1 : 2;
Isabella Gottardid17a6772018-02-27 17:41:55 +0000389 break;
390 case DataLayoutDimension::WIDTH:
Isabella Gottardid56e7702018-02-28 14:29:36 +0000391 return (data_layout == DataLayout::NCHW) ? 0 : 1;
Isabella Gottardid17a6772018-02-27 17:41:55 +0000392 break;
393 case DataLayoutDimension::BATCHES:
394 return 3;
395 break;
396 default:
397 ARM_COMPUTE_ERROR("Data layout index not supported!");
398 break;
399 }
400}
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100401} // namespace arm_compute