1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
16// Third party copyrights are property of their respective owners.
17//
18// Redistribution and use in source and binary forms, with or without modification,
19// are permitted provided that the following conditions are met:
20//
21// * Redistribution's of source code must retain the above copyright notice,
22// this list of conditions and the following disclaimer.
23//
24// * Redistribution's in binary form must reproduce the above copyright notice,
25// this list of conditions and the following disclaimer in the documentation
26// and/or other materials provided with the distribution.
27//
28// * The name of the copyright holders may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// This software is provided by the copyright holders and contributors "as is" and
32// any express or implied warranties, including, but not limited to, the implied
33// warranties of merchantability and fitness for a particular purpose are disclaimed.
34// In no event shall the Intel Corporation or contributors be liable for any direct,
35// indirect, incidental, special, exemplary, or consequential damages
36// (including, but not limited to, procurement of substitute goods or services;
37// loss of use, data, or profits; or business interruption) however caused
38// and on any theory of liability, whether in contract, strict liability,
39// or tort (including negligence or otherwise) arising in any way out of
40// the use of this software, even if advised of the possibility of such damage.
41//
42//M*/
43
44#include "precomp.hpp"
45#undef CV_FORCE_SIMD128_CPP // expected AVX implementation only
46#include "opencv2/core/hal/intrin.hpp"
47#include "corner.hpp"
48
49namespace cv
50{
51
52// load three 8-packed float vector and deinterleave
53// probably it's better to write down somewhere else
54static void load_deinterleave(const float* ptr, __m256& a, __m256& b, __m256& c)
55{
56 __m256 s0 = _mm256_loadu_ps(p: ptr); // a0, b0, c0, a1, b1, c1, a2, b2,
57 __m256 s1 = _mm256_loadu_ps(p: ptr + 8); // c2, a3, b3, c3, a4, b4, c4, a5,
58 __m256 s2 = _mm256_loadu_ps(p: ptr + 16); // b5, c5, a6, b6, c6, a7, b7, c7,
59 __m256 s3 = _mm256_permute2f128_ps(s1, s2, 0x21); // a4, b4, c4, a5, b5, c5, a6, b6,
60 __m256 s4 = _mm256_permute2f128_ps(s2, s2, 0x33); // c6, a7, b7, c7, c6, a7, b7, c7,
61
62 __m256 v00 = _mm256_unpacklo_ps(a: s0, b: s3); // a0, a4, b0, b4, b1, b5, c1, c5,
63 __m256 v01 = _mm256_unpackhi_ps(a: s0, b: s3); // c0, c4, a1, a5, a2, a6, b2, b6,
64 __m256 v02 = _mm256_unpacklo_ps(a: s1, b: s4); // c2, c6, a3, a7, x, x, x, x,
65 __m256 v03 = _mm256_unpackhi_ps(a: s1, b: s4); // b3, b7, c3, c7, x, x, x, x,
66 __m256 v04 = _mm256_permute2f128_ps(v02, v03, 0x20); // c2, c6, a3, a7, b3, b7, c3, c7,
67 __m256 v05 = _mm256_permute2f128_ps(v01, v03, 0x21); // a2, a6, b2, b6, b3, b7, c3, c7,
68
69 __m256 v10 = _mm256_unpacklo_ps(a: v00, b: v05); // a0, a2, a4, a6, b1, b3, b5, b7,
70 __m256 v11 = _mm256_unpackhi_ps(a: v00, b: v05); // b0, b2, b4, b6, c1, c3, c5, c7,
71 __m256 v12 = _mm256_unpacklo_ps(a: v01, b: v04); // c0, c2, c4, c6, x, x, x, x,
72 __m256 v13 = _mm256_unpackhi_ps(a: v01, b: v04); // a1, a3, a5, a7, x, x, x, x,
73 __m256 v14 = _mm256_permute2f128_ps(v11, v12, 0x20); // b0, b2, b4, b6, c0, c2, c4, c6,
74 __m256 v15 = _mm256_permute2f128_ps(v10, v11, 0x31); // b1, b3, b5, b7, c1, c3, c5, c7,
75
76 __m256 v20 = _mm256_unpacklo_ps(a: v14, b: v15); // b0, b1, b2, b3, c0, c1, c2, c3,
77 __m256 v21 = _mm256_unpackhi_ps(a: v14, b: v15); // b4, b5, b6, b7, c4, c5, c6, c7,
78 __m256 v22 = _mm256_unpacklo_ps(a: v10, b: v13); // a0, a1, a2, a3, x, x, x, x,
79 __m256 v23 = _mm256_unpackhi_ps(a: v10, b: v13); // a4, a5, a6, a7, x, x, x, x,
80
81 a = _mm256_permute2f128_ps(v22, v23, 0x20); // a0, a1, a2, a3, a4, a5, a6, a7,
82 b = _mm256_permute2f128_ps(v20, v21, 0x20); // b0, b1, b2, b3, b4, b5, b6, b7,
83 c = _mm256_permute2f128_ps(v20, v21, 0x31); // c0, c1, c2, c3, c4, c5, c6, c7,
84}
85
86// realign four 3-packed vector to three 4-packed vector
87static void v_pack4x3to3x4(const __m128i& s0, const __m128i& s1, const __m128i& s2, const __m128i& s3, __m128i& d0, __m128i& d1, __m128i& d2)
88{
89 d0 = _mm_or_si128(a: s0, _mm_slli_si128(s1, 12));
90 d1 = _mm_or_si128(_mm_srli_si128(s1, 4), _mm_slli_si128(s2, 8));
91 d2 = _mm_or_si128(_mm_srli_si128(s2, 8), _mm_slli_si128(s3, 4));
92}
93
94// separate high and low 128 bit and cast to __m128i
95static void v_separate_lo_hi(const __m256& src, __m128i& lo, __m128i& hi)
96{
97 lo = _mm_castps_si128(a: _mm256_castps256_ps128(a: src));
98 hi = _mm_castps_si128(_mm256_extractf128_ps(src, 1));
99}
100
101// interleave three 8-float vector and store
102static void store_interleave(float* ptr, const __m256& a, const __m256& b, const __m256& c)
103{
104 __m128i a0, a1, b0, b1, c0, c1;
105 v_separate_lo_hi(src: a, lo&: a0, hi&: a1);
106 v_separate_lo_hi(src: b, lo&: b0, hi&: b1);
107 v_separate_lo_hi(src: c, lo&: c0, hi&: c1);
108
109 v_uint32x4 z = v_setzero_u32();
110 v_uint32x4 u0, u1, u2, u3;
111 v_transpose4x4(a0: v_uint32x4(a0), a1: v_uint32x4(b0), a2: v_uint32x4(c0), a3: z, b0&: u0, b1&: u1, b2&: u2, b3&: u3);
112 v_pack4x3to3x4(s0: u0.val, s1: u1.val, s2: u2.val, s3: u3.val, d0&: a0, d1&: b0, d2&: c0);
113 v_transpose4x4(a0: v_uint32x4(a1), a1: v_uint32x4(b1), a2: v_uint32x4(c1), a3: z, b0&: u0, b1&: u1, b2&: u2, b3&: u3);
114 v_pack4x3to3x4(s0: u0.val, s1: u1.val, s2: u2.val, s3: u3.val, d0&: a1, d1&: b1, d2&: c1);
115
116#if !defined(__GNUC__) || defined(__INTEL_COMPILER)
117 _mm256_storeu_ps(ptr, _mm256_castsi256_ps(_mm256_setr_m128i(a0, b0)));
118 _mm256_storeu_ps(ptr + 8, _mm256_castsi256_ps(_mm256_setr_m128i(c0, a1)));
119 _mm256_storeu_ps(ptr + 16, _mm256_castsi256_ps(_mm256_setr_m128i(b1, c1)));
120#else
121 // GCC: workaround for missing AVX intrinsic: "_mm256_setr_m128()"
122 _mm256_storeu_ps(p: ptr, _mm256_insertf128_ps(_mm256_castps128_ps256(_mm_castsi128_ps(a0)), _mm_castsi128_ps(b0), 1));
123 _mm256_storeu_ps(p: ptr + 8, _mm256_insertf128_ps(_mm256_castps128_ps256(_mm_castsi128_ps(c0)), _mm_castsi128_ps(a1), 1));
124 _mm256_storeu_ps(p: ptr + 16, _mm256_insertf128_ps(_mm256_castps128_ps256(_mm_castsi128_ps(b1)), _mm_castsi128_ps(c1), 1));
125#endif
126}
127
128int calcMinEigenValLine_AVX(const float* cov, float* dst, int width)
129{
130 int j = 0;
131 __m256 half = _mm256_set1_ps(w: 0.5f);
132 for (; j <= width - 8; j += 8)
133 {
134 __m256 v_a, v_b, v_c, v_t;
135 load_deinterleave(ptr: cov + j * 3, a&: v_a, b&: v_b, c&: v_c);
136 v_a = _mm256_mul_ps(a: v_a, b: half);
137 v_c = _mm256_mul_ps(a: v_c, b: half);
138 v_t = _mm256_sub_ps(a: v_a, b: v_c);
139 v_t = _mm256_add_ps(a: _mm256_mul_ps(a: v_b, b: v_b), b: _mm256_mul_ps(a: v_t, b: v_t));
140 _mm256_storeu_ps(p: dst + j, a: _mm256_sub_ps(a: _mm256_add_ps(a: v_a, b: v_c), b: _mm256_sqrt_ps(a: v_t)));
141 }
142 return j;
143}
144
145int calcHarrisLine_AVX(const float* cov, float* dst, double k, int width)
146{
147 int j = 0;
148 __m256 v_k = _mm256_set1_ps(w: (float)k);
149
150 for (; j <= width - 8; j += 8)
151 {
152 __m256 v_a, v_b, v_c;
153 load_deinterleave(ptr: cov + j * 3, a&: v_a, b&: v_b, c&: v_c);
154
155 __m256 v_ac_bb = _mm256_sub_ps(a: _mm256_mul_ps(a: v_a, b: v_c), b: _mm256_mul_ps(a: v_b, b: v_b));
156 __m256 v_ac = _mm256_add_ps(a: v_a, b: v_c);
157 __m256 v_dst = _mm256_sub_ps(a: v_ac_bb, b: _mm256_mul_ps(a: v_k, b: _mm256_mul_ps(a: v_ac, b: v_ac)));
158 _mm256_storeu_ps(p: dst + j, a: v_dst);
159 }
160 return j;
161}
162
163int cornerEigenValsVecsLine_AVX(const float* dxdata, const float* dydata, float* cov_data, int width)
164{
165 int j = 0;
166 for (; j <= width - 8; j += 8)
167 {
168 __m256 v_dx = _mm256_loadu_ps(p: dxdata + j);
169 __m256 v_dy = _mm256_loadu_ps(p: dydata + j);
170
171 __m256 v_dst0, v_dst1, v_dst2;
172 v_dst0 = _mm256_mul_ps(a: v_dx, b: v_dx);
173 v_dst1 = _mm256_mul_ps(a: v_dx, b: v_dy);
174 v_dst2 = _mm256_mul_ps(a: v_dy, b: v_dy);
175
176 store_interleave(ptr: cov_data + j * 3, a: v_dst0, b: v_dst1, c: v_dst2);
177 }
178 return j;
179}
180
181}
182/* End of file */
183

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of opencv/modules/imgproc/src/corner.avx.cpp