Compute Library
 22.11
warp_helpers.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016, 2017, 2021 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 #include "helpers.h"
25 
26 /** Clamps the given coordinates to the borders according to the border size.
27  *
28  * @param[in] coords Vector of 2D coordinates to clamp. Even positions are X coords, odd positions are Y coords.
29  * @param[in] width Width of the image
30  * @param[in] height Height of the image
31  * @param[in] border_size Border size of the image
32  *
33  */
34 inline const float8 clamp_to_border_with_size(float8 coords, const float width, const float height, const float border_size)
35 {
36  const float4 clamped_x = clamp(coords.even, 0.0f - border_size, width - 1 + border_size);
37  const float4 clamped_y = clamp(coords.odd, 0.0f - border_size, height - 1 + border_size);
38  return (float8)(clamped_x.s0, clamped_y.s0, clamped_x.s1, clamped_y.s1, clamped_x.s2, clamped_y.s2, clamped_x.s3, clamped_y.s3);
39 }
40 
41 /** Clamps the given coordinates to the borders.
42  *
43  * @param[in] coords Vector of 2D coordinates to clamp. Even positions are X coords, odd positions are Y coords.
44  * @param[in] width Width of the image
45  * @param[in] height Height of the image
46  *
47  */
48 inline const float8 clamp_to_border(float8 coords, const float width, const float height)
49 {
50  return clamp_to_border_with_size(coords, width, height, 1);
51 }
52 
53 /** Reads four texels from the input image. The coords vector is used to determine which texels to be read.
54  *
55  * @param[in] in Pointer to the source image.
56  * @param[in] coords Vector of coordinates to be read from the image.
57  */
58 inline const VEC_DATA_TYPE(DATA_TYPE, 4) read_texels4(const Image *in, const int8 coords)
59 {
60  return (VEC_DATA_TYPE(DATA_TYPE, 4))(*((__global DATA_TYPE *)offset(in, coords.s0, coords.s1)),
61  *((__global DATA_TYPE *)offset(in, coords.s2, coords.s3)),
62  *((__global DATA_TYPE *)offset(in, coords.s4, coords.s5)),
63  *((__global DATA_TYPE *)offset(in, coords.s6, coords.s7)));
64 }
65 
66 /** Given a texel coordinates this function will return the following array of coordinates:
67  * [ P, right neighbour, below neighbour, below right neighbour ]
68  *
69  * @note No checks to see if the coordinates are out of the image are done here.
70  *
71  * @param[in] coord Input coordinates
72  *
73  * @return vector of 8 floats with the coordinates, even positions are x and odd y.
74  */
75 inline const float8 get_neighbour_coords(const float2 coord)
76 {
77  return (float8)(/*tl*/ coord.s0, coord.s1, /*tr*/ coord.s0 + 1, coord.s1, /*bl*/ coord.s0, coord.s1 + 1, /*br*/ coord.s0 + 1, coord.s1 + 1);
78 }
79 
80 /** Computes the bilinear interpolation for each set of coordinates in the vector coords and returns the values
81  *
82  * @param[in] in Pointer to the source image.
83  * @param[in] coords Vector of four 2D coordinates. Even pos is x and odd y.
84  * @param[in] width Width of the image
85  * @param[in] height Height of the image
86  * @param[in] border_size Border size
87  */
88 inline const VEC_DATA_TYPE(DATA_TYPE, 4) bilinear_interpolate_with_border(const Image *in, const float8 coords, const float width, const float height, const float border_size)
89 {
90  // If any of the 4 texels is out of the image's boundaries we use the border value (REPLICATE or CONSTANT) for any texel out of the image.
91 
92  // Sets the 4x4 coordinates for each of the four input texels
93  const float8 fc = floor(coords);
94  const float16 c1 = (float16)(
95  clamp_to_border_with_size(get_neighbour_coords((float2)(fc.s0, fc.s1)), width, height, border_size),
96  clamp_to_border_with_size(get_neighbour_coords((float2)(fc.s2, fc.s3)), width, height, border_size));
97  const float16 c2 = (float16)(
98  clamp_to_border_with_size(get_neighbour_coords((float2)(fc.s4, fc.s5)), width, height, border_size),
99  clamp_to_border_with_size(get_neighbour_coords((float2)(fc.s6, fc.s7)), width, height, border_size));
100 
101  // Loads the values from the input image
102  const float16 t = (float16)(
103  /* tl, tr, bl, br */
104  * ((__global DATA_TYPE *)offset(in, c1.s0, c1.s1)), *((__global DATA_TYPE *)offset(in, c1.s2, c1.s3)),
105  *((__global DATA_TYPE *)offset(in, c1.s4, c1.s5)), *((__global DATA_TYPE *)offset(in, c1.s6, c1.s7)),
106  *((__global DATA_TYPE *)offset(in, c1.s8, c1.s9)), *((__global DATA_TYPE *)offset(in, c1.sa, c1.sb)),
107  *((__global DATA_TYPE *)offset(in, c1.sc, c1.sd)), *((__global DATA_TYPE *)offset(in, c1.se, c1.sf)),
108  *((__global DATA_TYPE *)offset(in, c2.s0, c2.s1)), *((__global DATA_TYPE *)offset(in, c2.s2, c2.s3)),
109  *((__global DATA_TYPE *)offset(in, c2.s4, c2.s5)), *((__global DATA_TYPE *)offset(in, c2.s6, c2.s7)),
110  *((__global DATA_TYPE *)offset(in, c2.s8, c2.s9)), *((__global DATA_TYPE *)offset(in, c2.sa, c2.sb)),
111  *((__global DATA_TYPE *)offset(in, c2.sc, c2.sd)), *((__global DATA_TYPE *)offset(in, c2.se, c2.sf)));
112  const float8 a = coords - fc;
113  const float8 b = ((float8)(1.f)) - a;
114  const float4 fr = (float4)(
115  ((t.s0 * b.s0 * b.s1) + (t.s1 * a.s0 * b.s1) + (t.s2 * b.s0 * a.s1) + (t.s3 * a.s0 * a.s1)),
116  ((t.s4 * b.s2 * b.s3) + (t.s5 * a.s2 * b.s3) + (t.s6 * b.s2 * a.s3) + (t.s7 * a.s2 * a.s3)),
117  ((t.s8 * b.s4 * b.s5) + (t.s9 * a.s4 * b.s5) + (t.sa * b.s4 * a.s5) + (t.sb * a.s4 * a.s5)),
118  ((t.sc * b.s6 * b.s7) + (t.sd * a.s6 * b.s7) + (t.se * b.s6 * a.s7) + (t.sf * a.s6 * a.s7)));
119  return CONVERT(fr, VEC_DATA_TYPE(DATA_TYPE, 4));
120 }
121 
122 /** Computes the bilinear interpolation for each set of coordinates in the vector coords and returns the values
123  *
124  * @param[in] in Pointer to the source image.
125  * @param[in] coords Vector of four 2D coordinates. Even pos is x and odd y.
126  * @param[in] width Width of the image
127  * @param[in] height Height of the image
128  */
129 inline const VEC_DATA_TYPE(DATA_TYPE, 4) bilinear_interpolate(const Image *in, const float8 coords, const float width, const float height)
130 {
131  return bilinear_interpolate_with_border(in, coords, width, height, 1);
132 }
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:1084
#define CONVERT(x, type)
Definition: helpers.h:731
const float8 clamp_to_border(float8 coords, const float width, const float height)
Clamps the given coordinates to the borders.
Definition: warp_helpers.h:48
SimpleTensor< float > b
Definition: DFT.cpp:157
const DATA_TYPE4 bilinear_interpolate_with_border(const Image *in, const float8 coords, const float width, const float height, const float border_size)
Computes the bilinear interpolation for each set of coordinates in the vector coords and returns the ...
Definition: warp_helpers.h:88
DataType clamp(const DataType &n, const DataType &lower=std::numeric_limits< RangeType >::lowest(), const DataType &upper=std::numeric_limits< RangeType >::max())
Performs clamping among a lower and upper value.
Definition: Utility.h:101
const float8 get_neighbour_coords(const float2 coord)
Given a texel coordinates this function will return the following array of coordinates: [ P...
Definition: warp_helpers.h:75
Structure to hold Image information.
Definition: helpers.h:897
const DATA_TYPE4 read_texels4(const Image *in, const int8 coords)
Reads four texels from the input image.
Definition: warp_helpers.h:58
const float8 clamp_to_border_with_size(float8 coords, const float width, const float height, const float border_size)
Clamps the given coordinates to the borders according to the border size.
Definition: warp_helpers.h:34
const DATA_TYPE4 bilinear_interpolate(const Image *in, const float8 coords, const float width, const float height)
Computes the bilinear interpolation for each set of coordinates in the vector coords and returns the ...
Definition: warp_helpers.h:129
#define VEC_DATA_TYPE(type, size)
Definition: helpers.h:728