mirror of
https://github.com/opencv/opencv.git
synced 2026-07-30 15:53:03 +04:00
Merge pull request #26999 from GenshinImpactStarts:polar_to_cart
[HAL RVV] unify and impl polar_to_cart | add perf test #26999 ### Summary 1. Implement through the existing `cv_hal_polarToCart32f` and `cv_hal_polarToCart64f` interfaces. 2. Add `polarToCart` performance tests 3. Make `cv::polarToCart` use CALL_HAL in the same way as `cv::cartToPolar` 4. To achieve the 3rd point, the original implementation was moved, and some modifications were made. Tested through: ```sh opencv_test_core --gtest_filter="*PolarToCart*:*Core_CartPolar_reverse*" opencv_perf_core --gtest_filter="*PolarToCart*" --perf_min_samples=300 --perf_force_samples=300 ``` ### HAL performance test ***UPDATE***: Current implementation is no more depending on vlen. **NOTE**: Due to the 4th point in the summary above, the `scalar` and `ui` test is based on the modified code of this PR. The impact of this patch on `scalar` and `ui` is evaluated in the next section, `Effect of Point 4`. Vlen 256 (Muse Pi): ``` Name of Test scalar ui rvv ui rvv vs vs scalar scalar (x-factor) (x-factor) PolarToCart::PolarToCartFixture::(127x61, 32FC1) 0.315 0.110 0.034 2.85 9.34 PolarToCart::PolarToCartFixture::(127x61, 64FC1) 0.423 0.163 0.045 2.59 9.34 PolarToCart::PolarToCartFixture::(640x480, 32FC1) 13.695 4.325 1.278 3.17 10.71 PolarToCart::PolarToCartFixture::(640x480, 64FC1) 17.719 7.118 2.105 2.49 8.42 PolarToCart::PolarToCartFixture::(1280x720, 32FC1) 40.678 13.114 3.977 3.10 10.23 PolarToCart::PolarToCartFixture::(1280x720, 64FC1) 53.124 21.298 6.519 2.49 8.15 PolarToCart::PolarToCartFixture::(1920x1080, 32FC1) 95.158 29.465 8.894 3.23 10.70 PolarToCart::PolarToCartFixture::(1920x1080, 64FC1) 119.262 47.743 14.129 2.50 8.44 ``` ### Effect of Point 4 To make `cv::polarToCart` behave the same as `cv::cartToPolar`, the implementation detail of the former has been moved to the latter's location (from `mathfuncs.cpp` to `mathfuncs_core.simd.hpp`). #### Reason for Changes: This function works as follows: $y = \text{mag} \times \sin(\text{angle})$ and $x = \text{mag} \times \cos(\text{angle})$. The original implementation first calculates the values of $\sin$ and $\cos$, storing the results in the output buffers $x$ and $y$, and then multiplies the result by $\text{mag}$. However, when the function is used as an in-place operation (one of the output buffers is also an input buffer), the original implementation allocates an extra buffer to store the $\sin$ and $\cos$ values in case the $\text{mag}$ value gets overwritten. This extra buffer allocation prevents `cv::polarToCart` from functioning in the same way as `cv::cartToPolar`. Therefore, the multiplication is now performed immediately without storing intermediate values. Since the original implementation also had AVX2 optimizations, I have applied the same optimizations to the AVX2 version of this implementation. ***UPDATE***: UI use v_sincos from #25892 now. The original implementation has AVX2 optimizations but is slower much than current UI so it's removed, and AVX2 perf test is below. Scalar implementation isn't changed because it's faster than using UI's method. #### Test Result `scalar` and `ui` test is done on Muse PI, and AVX2 test is done on Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz. `scalar` test: ``` Name of Test orig pr pr vs orig (x-factor) PolarToCart::PolarToCartFixture::(127x61, 32FC1) 0.333 0.294 1.13 PolarToCart::PolarToCartFixture::(127x61, 64FC1) 0.385 0.403 0.96 PolarToCart::PolarToCartFixture::(640x480, 32FC1) 14.749 12.343 1.19 PolarToCart::PolarToCartFixture::(640x480, 64FC1) 19.419 16.743 1.16 PolarToCart::PolarToCartFixture::(1280x720, 32FC1) 44.155 37.822 1.17 PolarToCart::PolarToCartFixture::(1280x720, 64FC1) 62.108 50.358 1.23 PolarToCart::PolarToCartFixture::(1920x1080, 32FC1) 99.011 85.769 1.15 PolarToCart::PolarToCartFixture::(1920x1080, 64FC1) 127.740 112.874 1.13 ``` `ui` test: ``` Name of Test orig pr pr vs orig (x-factor) PolarToCart::PolarToCartFixture::(127x61, 32FC1) 0.306 0.110 2.77 PolarToCart::PolarToCartFixture::(127x61, 64FC1) 0.455 0.163 2.79 PolarToCart::PolarToCartFixture::(640x480, 32FC1) 13.381 4.325 3.09 PolarToCart::PolarToCartFixture::(640x480, 64FC1) 21.851 7.118 3.07 PolarToCart::PolarToCartFixture::(1280x720, 32FC1) 39.975 13.114 3.05 PolarToCart::PolarToCartFixture::(1280x720, 64FC1) 67.006 21.298 3.15 PolarToCart::PolarToCartFixture::(1920x1080, 32FC1) 90.362 29.465 3.07 PolarToCart::PolarToCartFixture::(1920x1080, 64FC1) 129.637 47.743 2.72 ``` AVX2 test: ``` Name of Test orig pr pr vs orig (x-factor) PolarToCart::PolarToCartFixture::(127x61, 32FC1) 0.019 0.009 2.11 PolarToCart::PolarToCartFixture::(127x61, 64FC1) 0.022 0.013 1.74 PolarToCart::PolarToCartFixture::(640x480, 32FC1) 0.788 0.355 2.22 PolarToCart::PolarToCartFixture::(640x480, 64FC1) 1.102 0.618 1.78 PolarToCart::PolarToCartFixture::(1280x720, 32FC1) 2.383 1.042 2.29 PolarToCart::PolarToCartFixture::(1280x720, 64FC1) 3.758 2.316 1.62 PolarToCart::PolarToCartFixture::(1920x1080, 32FC1) 5.577 2.559 2.18 PolarToCart::PolarToCartFixture::(1920x1080, 64FC1) 9.710 6.424 1.51 ``` A slight performance loss occurs because the check for whether $mag$ is nullptr is performed with every calculation, instead of being done once per batch. This is to reuse current `SinCos_32f` function. ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [ ] The PR is proposed to the proper branch - [ ] There is a reference to the original bug report and related work - [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [ ] The feature is well documented and sample code can be built with the project CMake
This commit is contained in:
GenshinImpactStarts
committed by
GitHub
GitHub
parent
b6f213a8c7
commit
2090407002
@@ -328,149 +328,6 @@ void cartToPolar( InputArray src1, InputArray src2,
|
||||
* Polar -> Cartezian *
|
||||
\****************************************************************************************/
|
||||
|
||||
static void SinCos_32f( const float *angle, float *sinval, float* cosval,
|
||||
int len, int angle_in_degrees )
|
||||
{
|
||||
const int N = 64;
|
||||
|
||||
static const double sin_table[] =
|
||||
{
|
||||
0.00000000000000000000, 0.09801714032956060400,
|
||||
0.19509032201612825000, 0.29028467725446233000,
|
||||
0.38268343236508978000, 0.47139673682599764000,
|
||||
0.55557023301960218000, 0.63439328416364549000,
|
||||
0.70710678118654746000, 0.77301045336273699000,
|
||||
0.83146961230254524000, 0.88192126434835494000,
|
||||
0.92387953251128674000, 0.95694033573220894000,
|
||||
0.98078528040323043000, 0.99518472667219682000,
|
||||
1.00000000000000000000, 0.99518472667219693000,
|
||||
0.98078528040323043000, 0.95694033573220894000,
|
||||
0.92387953251128674000, 0.88192126434835505000,
|
||||
0.83146961230254546000, 0.77301045336273710000,
|
||||
0.70710678118654757000, 0.63439328416364549000,
|
||||
0.55557023301960218000, 0.47139673682599786000,
|
||||
0.38268343236508989000, 0.29028467725446239000,
|
||||
0.19509032201612861000, 0.09801714032956082600,
|
||||
0.00000000000000012246, -0.09801714032956059000,
|
||||
-0.19509032201612836000, -0.29028467725446211000,
|
||||
-0.38268343236508967000, -0.47139673682599764000,
|
||||
-0.55557023301960196000, -0.63439328416364527000,
|
||||
-0.70710678118654746000, -0.77301045336273666000,
|
||||
-0.83146961230254524000, -0.88192126434835494000,
|
||||
-0.92387953251128652000, -0.95694033573220882000,
|
||||
-0.98078528040323032000, -0.99518472667219693000,
|
||||
-1.00000000000000000000, -0.99518472667219693000,
|
||||
-0.98078528040323043000, -0.95694033573220894000,
|
||||
-0.92387953251128663000, -0.88192126434835505000,
|
||||
-0.83146961230254546000, -0.77301045336273688000,
|
||||
-0.70710678118654768000, -0.63439328416364593000,
|
||||
-0.55557023301960218000, -0.47139673682599792000,
|
||||
-0.38268343236509039000, -0.29028467725446250000,
|
||||
-0.19509032201612872000, -0.09801714032956050600,
|
||||
};
|
||||
|
||||
static const double k2 = (2*CV_PI)/N;
|
||||
|
||||
static const double sin_a0 = -0.166630293345647*k2*k2*k2;
|
||||
static const double sin_a2 = k2;
|
||||
|
||||
static const double cos_a0 = -0.499818138450326*k2*k2;
|
||||
/*static const double cos_a2 = 1;*/
|
||||
|
||||
double k1;
|
||||
int i = 0;
|
||||
|
||||
if( !angle_in_degrees )
|
||||
k1 = N/(2*CV_PI);
|
||||
else
|
||||
k1 = N/360.;
|
||||
|
||||
#if CV_AVX2
|
||||
if (USE_AVX2)
|
||||
{
|
||||
__m128d v_k1 = _mm_set1_pd(k1);
|
||||
__m128d v_1 = _mm_set1_pd(1);
|
||||
__m128i v_N1 = _mm_set1_epi32(N - 1);
|
||||
__m128i v_N4 = _mm_set1_epi32(N >> 2);
|
||||
__m128d v_sin_a0 = _mm_set1_pd(sin_a0);
|
||||
__m128d v_sin_a2 = _mm_set1_pd(sin_a2);
|
||||
__m128d v_cos_a0 = _mm_set1_pd(cos_a0);
|
||||
|
||||
for ( ; i <= len - 4; i += 4)
|
||||
{
|
||||
__m128 v_angle = _mm_loadu_ps(angle + i);
|
||||
|
||||
// 0-1
|
||||
__m128d v_t = _mm_mul_pd(_mm_cvtps_pd(v_angle), v_k1);
|
||||
__m128i v_it = _mm_cvtpd_epi32(v_t);
|
||||
v_t = _mm_sub_pd(v_t, _mm_cvtepi32_pd(v_it));
|
||||
|
||||
__m128i v_sin_idx = _mm_and_si128(v_it, v_N1);
|
||||
__m128i v_cos_idx = _mm_and_si128(_mm_sub_epi32(v_N4, v_sin_idx), v_N1);
|
||||
|
||||
__m128d v_t2 = _mm_mul_pd(v_t, v_t);
|
||||
__m128d v_sin_b = _mm_mul_pd(_mm_add_pd(_mm_mul_pd(v_sin_a0, v_t2), v_sin_a2), v_t);
|
||||
__m128d v_cos_b = _mm_add_pd(_mm_mul_pd(v_cos_a0, v_t2), v_1);
|
||||
|
||||
__m128d v_sin_a = _mm_i32gather_pd(sin_table, v_sin_idx, 8);
|
||||
__m128d v_cos_a = _mm_i32gather_pd(sin_table, v_cos_idx, 8);
|
||||
|
||||
__m128d v_sin_val_0 = _mm_add_pd(_mm_mul_pd(v_sin_a, v_cos_b),
|
||||
_mm_mul_pd(v_cos_a, v_sin_b));
|
||||
__m128d v_cos_val_0 = _mm_sub_pd(_mm_mul_pd(v_cos_a, v_cos_b),
|
||||
_mm_mul_pd(v_sin_a, v_sin_b));
|
||||
|
||||
// 2-3
|
||||
v_t = _mm_mul_pd(_mm_cvtps_pd(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_angle), 8))), v_k1);
|
||||
v_it = _mm_cvtpd_epi32(v_t);
|
||||
v_t = _mm_sub_pd(v_t, _mm_cvtepi32_pd(v_it));
|
||||
|
||||
v_sin_idx = _mm_and_si128(v_it, v_N1);
|
||||
v_cos_idx = _mm_and_si128(_mm_sub_epi32(v_N4, v_sin_idx), v_N1);
|
||||
|
||||
v_t2 = _mm_mul_pd(v_t, v_t);
|
||||
v_sin_b = _mm_mul_pd(_mm_add_pd(_mm_mul_pd(v_sin_a0, v_t2), v_sin_a2), v_t);
|
||||
v_cos_b = _mm_add_pd(_mm_mul_pd(v_cos_a0, v_t2), v_1);
|
||||
|
||||
v_sin_a = _mm_i32gather_pd(sin_table, v_sin_idx, 8);
|
||||
v_cos_a = _mm_i32gather_pd(sin_table, v_cos_idx, 8);
|
||||
|
||||
__m128d v_sin_val_1 = _mm_add_pd(_mm_mul_pd(v_sin_a, v_cos_b),
|
||||
_mm_mul_pd(v_cos_a, v_sin_b));
|
||||
__m128d v_cos_val_1 = _mm_sub_pd(_mm_mul_pd(v_cos_a, v_cos_b),
|
||||
_mm_mul_pd(v_sin_a, v_sin_b));
|
||||
|
||||
_mm_storeu_ps(sinval + i, _mm_movelh_ps(_mm_cvtpd_ps(v_sin_val_0),
|
||||
_mm_cvtpd_ps(v_sin_val_1)));
|
||||
_mm_storeu_ps(cosval + i, _mm_movelh_ps(_mm_cvtpd_ps(v_cos_val_0),
|
||||
_mm_cvtpd_ps(v_cos_val_1)));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
for( ; i < len; i++ )
|
||||
{
|
||||
double t = angle[i]*k1;
|
||||
int it = cvRound(t);
|
||||
t -= it;
|
||||
int sin_idx = it & (N - 1);
|
||||
int cos_idx = (N/4 - sin_idx) & (N - 1);
|
||||
|
||||
double sin_b = (sin_a0*t*t + sin_a2)*t;
|
||||
double cos_b = cos_a0*t*t + 1;
|
||||
|
||||
double sin_a = sin_table[sin_idx];
|
||||
double cos_a = sin_table[cos_idx];
|
||||
|
||||
double sin_val = sin_a*cos_b + cos_a*sin_b;
|
||||
double cos_val = cos_a*cos_b - sin_a*sin_b;
|
||||
|
||||
sinval[i] = (float)sin_val;
|
||||
cosval[i] = (float)cos_val;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
static bool ocl_polarToCart( InputArray _mag, InputArray _angle,
|
||||
@@ -587,11 +444,13 @@ void polarToCart( InputArray src1, InputArray src2,
|
||||
|
||||
CV_Assert(dst1.getObj() != dst2.getObj());
|
||||
|
||||
#ifdef HAVE_IPP
|
||||
const bool isInPlace =
|
||||
(src1.getObj() == dst1.getObj()) ||
|
||||
(src1.getObj() == dst2.getObj()) ||
|
||||
(src2.getObj() == dst1.getObj()) ||
|
||||
(src2.getObj() == dst2.getObj());
|
||||
#endif
|
||||
|
||||
int type = src2.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
|
||||
CV_Assert((depth == CV_32F || depth == CV_64F) && (src1.empty() || src1.type() == type));
|
||||
@@ -610,95 +469,25 @@ void polarToCart( InputArray src1, InputArray src2,
|
||||
const Mat* arrays[] = {&Mag, &Angle, &X, &Y, 0};
|
||||
uchar* ptrs[4] = {};
|
||||
NAryMatIterator it(arrays, ptrs);
|
||||
cv::AutoBuffer<float> _buf;
|
||||
float* buf[2] = {0, 0};
|
||||
int j, k, total = (int)(it.size*cn), blockSize = std::min(total, ((BLOCK_SIZE+cn-1)/cn)*cn);
|
||||
int j, total = (int)(it.size*cn), blockSize = std::min(total, ((BLOCK_SIZE+cn-1)/cn)*cn);
|
||||
size_t esz1 = Angle.elemSize1();
|
||||
|
||||
if (( depth == CV_64F ) || isInPlace)
|
||||
{
|
||||
_buf.allocate(blockSize*2);
|
||||
buf[0] = _buf.data();
|
||||
buf[1] = buf[0] + blockSize;
|
||||
}
|
||||
|
||||
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
||||
{
|
||||
for( j = 0; j < total; j += blockSize )
|
||||
{
|
||||
int len = std::min(total - j, blockSize);
|
||||
if (( depth == CV_32F ) && !isInPlace)
|
||||
if ( depth == CV_32F )
|
||||
{
|
||||
const float *mag = (const float*)ptrs[0], *angle = (const float*)ptrs[1];
|
||||
float *x = (float*)ptrs[2], *y = (float*)ptrs[3];
|
||||
|
||||
SinCos_32f( angle, y, x, len, angleInDegrees );
|
||||
if( mag )
|
||||
{
|
||||
k = 0;
|
||||
|
||||
#if (CV_SIMD || CV_SIMD_SCALABLE)
|
||||
int cWidth = VTraits<v_float32>::vlanes();
|
||||
for( ; k <= len - cWidth; k += cWidth )
|
||||
{
|
||||
v_float32 v_m = vx_load(mag + k);
|
||||
v_store(x + k, v_mul(vx_load(x + k), v_m));
|
||||
v_store(y + k, v_mul(vx_load(y + k), v_m));
|
||||
}
|
||||
vx_cleanup();
|
||||
#endif
|
||||
|
||||
for( ; k < len; k++ )
|
||||
{
|
||||
float m = mag[k];
|
||||
x[k] *= m; y[k] *= m;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (( depth == CV_32F ) && isInPlace)
|
||||
{
|
||||
const float *mag = (const float*)ptrs[0], *angle = (const float*)ptrs[1];
|
||||
float *x = (float*)ptrs[2], *y = (float*)ptrs[3];
|
||||
|
||||
for( k = 0; k < len; k++ )
|
||||
buf[0][k] = (float)angle[k];
|
||||
|
||||
SinCos_32f( buf[0], buf[1], buf[0], len, angleInDegrees );
|
||||
if( mag )
|
||||
for( k = 0; k < len; k++ )
|
||||
{
|
||||
float m = mag[k];
|
||||
x[k] = buf[0][k]*m; y[k] = buf[1][k]*m;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::memcpy(x, buf[0], sizeof(float) * len);
|
||||
std::memcpy(y, buf[1], sizeof(float) * len);
|
||||
}
|
||||
hal::polarToCart32f( mag, angle, x, y, len, angleInDegrees );
|
||||
}
|
||||
else
|
||||
{
|
||||
const double *mag = (const double*)ptrs[0], *angle = (const double*)ptrs[1];
|
||||
double *x = (double*)ptrs[2], *y = (double*)ptrs[3];
|
||||
|
||||
for( k = 0; k < len; k++ )
|
||||
buf[0][k] = (float)angle[k];
|
||||
|
||||
SinCos_32f( buf[0], buf[1], buf[0], len, angleInDegrees );
|
||||
if( mag )
|
||||
for( k = 0; k < len; k++ )
|
||||
{
|
||||
double m = mag[k];
|
||||
x[k] = buf[0][k]*m; y[k] = buf[1][k]*m;
|
||||
}
|
||||
else
|
||||
{
|
||||
for( k = 0; k < len; k++ )
|
||||
{
|
||||
x[k] = buf[0][k];
|
||||
y[k] = buf[1][k];
|
||||
}
|
||||
}
|
||||
hal::polarToCart64f( mag, angle, x, y, len, angleInDegrees );
|
||||
}
|
||||
|
||||
if( ptrs[0] )
|
||||
|
||||
@@ -29,6 +29,26 @@ void cartToPolar64f(const double* x, const double* y, double* mag, double* angle
|
||||
CV_CPU_DISPATCH_MODES_ALL);
|
||||
}
|
||||
|
||||
void polarToCart32f(const float* mag, const float* angle, float* x, float* y, int len, bool angleInDegrees)
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
|
||||
CALL_HAL(polarToCart32f, cv_hal_polarToCart32f, mag, angle, x, y, len, angleInDegrees);
|
||||
|
||||
CV_CPU_DISPATCH(polarToCart32f, (mag, angle, x, y, len, angleInDegrees),
|
||||
CV_CPU_DISPATCH_MODES_ALL);
|
||||
}
|
||||
|
||||
void polarToCart64f(const double* mag, const double* angle, double* x, double* y, int len, bool angleInDegrees)
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
|
||||
CALL_HAL(polarToCart64f, cv_hal_polarToCart64f, mag, angle, x, y, len, angleInDegrees);
|
||||
|
||||
CV_CPU_DISPATCH(polarToCart64f, (mag, angle, x, y, len, angleInDegrees),
|
||||
CV_CPU_DISPATCH_MODES_ALL);
|
||||
}
|
||||
|
||||
void fastAtan32f(const float *Y, const float *X, float *angle, int len, bool angleInDegrees )
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
|
||||
@@ -11,6 +11,8 @@ CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
|
||||
// forward declarations
|
||||
void cartToPolar32f(const float *X, const float *Y, float* mag, float *angle, int len, bool angleInDegrees);
|
||||
void cartToPolar64f(const double *X, const double *Y, double* mag, double *angle, int len, bool angleInDegrees);
|
||||
void polarToCart32f(const float *mag, const float *angle, float *X, float *Y, int len, bool angleInDegrees);
|
||||
void polarToCart64f(const double *mag, const double *angle, double *X, double *Y, int len, bool angleInDegrees);
|
||||
void fastAtan32f(const float *Y, const float *X, float *angle, int len, bool angleInDegrees);
|
||||
void fastAtan64f(const double *Y, const double *X, double *angle, int len, bool angleInDegrees);
|
||||
void fastAtan2(const float *Y, const float *X, float *angle, int len, bool angleInDegrees);
|
||||
@@ -178,6 +180,167 @@ void cartToPolar64f(const double *X, const double *Y, double *mag, double *angle
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
static inline void SinCos_32f(const float* mag, const float* angle, float* cosval, float* sinval, int len, int angle_in_degrees)
|
||||
{
|
||||
const int N = 64;
|
||||
|
||||
static const double sin_table[] =
|
||||
{
|
||||
0.00000000000000000000, 0.09801714032956060400,
|
||||
0.19509032201612825000, 0.29028467725446233000,
|
||||
0.38268343236508978000, 0.47139673682599764000,
|
||||
0.55557023301960218000, 0.63439328416364549000,
|
||||
0.70710678118654746000, 0.77301045336273699000,
|
||||
0.83146961230254524000, 0.88192126434835494000,
|
||||
0.92387953251128674000, 0.95694033573220894000,
|
||||
0.98078528040323043000, 0.99518472667219682000,
|
||||
1.00000000000000000000, 0.99518472667219693000,
|
||||
0.98078528040323043000, 0.95694033573220894000,
|
||||
0.92387953251128674000, 0.88192126434835505000,
|
||||
0.83146961230254546000, 0.77301045336273710000,
|
||||
0.70710678118654757000, 0.63439328416364549000,
|
||||
0.55557023301960218000, 0.47139673682599786000,
|
||||
0.38268343236508989000, 0.29028467725446239000,
|
||||
0.19509032201612861000, 0.09801714032956082600,
|
||||
0.00000000000000012246, -0.09801714032956059000,
|
||||
-0.19509032201612836000, -0.29028467725446211000,
|
||||
-0.38268343236508967000, -0.47139673682599764000,
|
||||
-0.55557023301960196000, -0.63439328416364527000,
|
||||
-0.70710678118654746000, -0.77301045336273666000,
|
||||
-0.83146961230254524000, -0.88192126434835494000,
|
||||
-0.92387953251128652000, -0.95694033573220882000,
|
||||
-0.98078528040323032000, -0.99518472667219693000,
|
||||
-1.00000000000000000000, -0.99518472667219693000,
|
||||
-0.98078528040323043000, -0.95694033573220894000,
|
||||
-0.92387953251128663000, -0.88192126434835505000,
|
||||
-0.83146961230254546000, -0.77301045336273688000,
|
||||
-0.70710678118654768000, -0.63439328416364593000,
|
||||
-0.55557023301960218000, -0.47139673682599792000,
|
||||
-0.38268343236509039000, -0.29028467725446250000,
|
||||
-0.19509032201612872000, -0.09801714032956050600,
|
||||
};
|
||||
|
||||
static const double k2 = (2*CV_PI)/N;
|
||||
|
||||
static const double sin_a0 = -0.166630293345647*k2*k2*k2;
|
||||
static const double sin_a2 = k2;
|
||||
|
||||
static const double cos_a0 = -0.499818138450326*k2*k2;
|
||||
/*static const double cos_a2 = 1;*/
|
||||
|
||||
double k1;
|
||||
int i = 0;
|
||||
|
||||
if( !angle_in_degrees )
|
||||
k1 = N/(2*CV_PI);
|
||||
else
|
||||
k1 = N/360.;
|
||||
|
||||
#if (CV_SIMD || CV_SIMD_SCALABLE)
|
||||
const int VECSZ = VTraits<v_float32>::vlanes();
|
||||
const v_float32 scale = vx_setall_f32(angle_in_degrees ? (float)CV_PI / 180.f : 1.f);
|
||||
|
||||
for( ; i < len; i += VECSZ*2 )
|
||||
{
|
||||
if( i + VECSZ*2 > len )
|
||||
{
|
||||
// if it's inplace operation, we cannot repeatedly process
|
||||
// the tail for the second time, so we have to use the
|
||||
// scalar code
|
||||
if( i == 0 || angle == cosval || angle == sinval || mag == cosval || mag == sinval )
|
||||
break;
|
||||
i = len - VECSZ*2;
|
||||
}
|
||||
|
||||
v_float32 r0 = v_mul(vx_load(angle + i), scale);
|
||||
v_float32 r1 = v_mul(vx_load(angle + i + VECSZ), scale);
|
||||
|
||||
v_float32 c0, c1, s0, s1;
|
||||
v_sincos(r0, s0, c0);
|
||||
v_sincos(r1, s1, c1);
|
||||
|
||||
if( mag )
|
||||
{
|
||||
v_float32 m0 = vx_load(mag + i);
|
||||
v_float32 m1 = vx_load(mag + i + VECSZ);
|
||||
c0 = v_mul(c0, m0);
|
||||
c1 = v_mul(c1, m1);
|
||||
s0 = v_mul(s0, m0);
|
||||
s1 = v_mul(s1, m1);
|
||||
}
|
||||
|
||||
v_store(cosval + i, c0);
|
||||
v_store(cosval + i + VECSZ, c1);
|
||||
|
||||
v_store(sinval + i, s0);
|
||||
v_store(sinval + i + VECSZ, s1);
|
||||
}
|
||||
vx_cleanup();
|
||||
#endif
|
||||
|
||||
for( ; i < len; i++ )
|
||||
{
|
||||
double t = angle[i]*k1;
|
||||
int it = cvRound(t);
|
||||
t -= it;
|
||||
int sin_idx = it & (N - 1);
|
||||
int cos_idx = (N/4 - sin_idx) & (N - 1);
|
||||
|
||||
double sin_b = (sin_a0*t*t + sin_a2)*t;
|
||||
double cos_b = cos_a0*t*t + 1;
|
||||
|
||||
double sin_a = sin_table[sin_idx];
|
||||
double cos_a = sin_table[cos_idx];
|
||||
|
||||
double sin_val = sin_a*cos_b + cos_a*sin_b;
|
||||
double cos_val = cos_a*cos_b - sin_a*sin_b;
|
||||
|
||||
if (mag)
|
||||
{
|
||||
double mag_val = mag[i];
|
||||
sin_val *= mag_val;
|
||||
cos_val *= mag_val;
|
||||
}
|
||||
|
||||
sinval[i] = (float)sin_val;
|
||||
cosval[i] = (float)cos_val;
|
||||
}
|
||||
}
|
||||
|
||||
} // anonymous::
|
||||
|
||||
void polarToCart32f(const float *mag, const float *angle, float *X, float *Y, int len, bool angleInDegrees)
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
SinCos_32f(mag, angle, X, Y, len, angleInDegrees);
|
||||
}
|
||||
|
||||
void polarToCart64f(const double *mag, const double *angle, double *X, double *Y, int len, bool angleInDegrees)
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
|
||||
const int BLKSZ = 128;
|
||||
float ybuf[BLKSZ], xbuf[BLKSZ], _mbuf[BLKSZ], abuf[BLKSZ];
|
||||
float* mbuf = mag ? _mbuf : nullptr;
|
||||
for( int i = 0; i < len; i += BLKSZ )
|
||||
{
|
||||
int j, blksz = std::min(BLKSZ, len - i);
|
||||
for( j = 0; j < blksz; j++ )
|
||||
{
|
||||
if (mbuf)
|
||||
mbuf[j] = (float)mag[i + j];
|
||||
abuf[j] = (float)angle[i + j];
|
||||
}
|
||||
SinCos_32f(mbuf, abuf, xbuf, ybuf, blksz, angleInDegrees);
|
||||
for( j = 0; j < blksz; j++ )
|
||||
X[i + j] = xbuf[j];
|
||||
for( j = 0; j < blksz; j++ )
|
||||
Y[i + j] = ybuf[j];
|
||||
}
|
||||
}
|
||||
|
||||
static void fastAtan32f_(const float *Y, const float *X, float *angle, int len, bool angleInDegrees )
|
||||
{
|
||||
float scale = angleInDegrees ? 1.f : (float)(CV_PI/180);
|
||||
|
||||
Reference in New Issue
Block a user