staticinlinevoidvx_load_as(constshort* ptr, v_float32& a)

{ a =v_cvt_f32(v_reinterpret_as_s32(vx_load_expand(ptr))); }

v_float32vx_setall_local(double coeff) {

v_float32vx_setall_local(float coeff) {

returnv_setall_f32(coeff);

}

template<typename WT,typename VT>

voidv_inter_area_set_sum(int col_end,const WT *const buf,const VT &v_coeff,

WT *sum,int &x) {

#if CV_SIMD128_64F

staticinlinevoidvx_load_as(constdouble* ptr, v_float64& a)

{ a =v_load(ptr); }

v_float64vx_setall_local(double coeff) {

returnv_setall_f64(coeff);

}

#endif

template<typename T,typename WT,typename VT>

voidv_inter_area_set_or_update_sum(const T *const src,int n,bool do_set,

WT coeff, WT *sum) {

constexprint step = VT::nlanes;

for (x =0; x + step < col_end; x += step)

const VT v_coeff =vx_setall_local(coeff);

int x;

if (do_set)

{

const VT line =vx_load(buf + x);

v_store(sum + x, line * v_coeff);

for (x =0; x + step < n; x += step)

{

VT line;

vx_load_as(src + x, line);

v_store(sum + x, line * v_coeff);

}

for(; x < n; ++x) sum[x] = saturate_cast<WT>(src[x]) * coeff;

}

}

template<typename WT,typename VT>

voidv_inter_area_update_sum(int col_end,const WT *const buf,const VT &v_coeff,

WT *sum,int &x) {

constexprint step = VT::nlanes;

for (x =0; x + step < col_end; x += step)

{

const VT line =vx_load(buf + x);

const VT sum_x =vx_load(sum + x);

v_store(sum + x, sum_x + line * v_coeff);

for (x =0; x + step < n; x += step)

{

VT line;

vx_load_as(src + x, line);

const VT sum_x =vx_load(sum + x);

v_store(sum + x, sum_x + line * v_coeff);

}

for(; x < n; ++x) sum[x] += saturate_cast<WT>(src[x]) * coeff;

}

}

template<typename S>

voidv_inter_area_copy_or_not(const S* s,int n,float *d,floatconst**buf)

{

static_assert(!std::is_same<S,float>::value,"Do not specialize for float");

constexprint step = v_float32::nlanes;

int x =0;

for(; x + step < n; x += step)

#if !CV_SIMD128_64F

voidv_inter_area_set_or_update_sum(constdouble *const src,int n,bool do_set,

double coeff,double *sum) {

int x;

if (do_set)

{

v_float32 a;

vx_load_as(s + x, a);

v_store(d + x, a);

for(x =0; x < n; ++x) sum[x] = src[x] * coeff;

}

{

for(x =0; x < n; ++x) sum[x] += src[x] * coeff;

}

for(; x < n; ++x) d[x] = saturate_cast<float>(s[x]);

*buf = d;

}

voidv_inter_area_copy_or_not(constdouble* s,int n,double *d,constdouble **buf)

{

(void)n;

(void)d;

*buf = s;

}

voidv_inter_area_copy_or_not(constfloat* s,int n,float *d,constfloat **buf)

{

(void)n;

(void)d;

*buf = s;

}

#if CV_SIMD128_64F

template<>

v_float64vx_setall_local(double coeff) {

returnv_setall_f64(coeff);

}

#else

template<>

v_uint8vx_setall_local(double coeff) {

(void)coeff;

returnv_setall_u8(0);

}

template<>

voidv_inter_area_set_sum(int col_end,constdouble *const buf,const v_uint8 &v_coeff,

double *sum,int &x) {

(void)col_end;

(void)buf;

(void)v_coeff;

(void)sum;

x =0;

}

template<>

voidv_inter_area_update_sum(int col_end,constdouble *const buf,const v_uint8 &v_coeff,

double *sum,int &x) {

(void)col_end;

(void)buf;

(void)v_coeff;

(void)sum;

x =0;

}

#endif

}

Size dsize = dst->size();

constint cn = dst->channels();

dsize.width *= cn;

AutoBuffer<WT>_buffer(std::max(src->cols * cn, range.size() * cn));

const DecimateAlpha* xtab = xtab0;

constint xtab_size = xtab_size0;

WT *buf = _buffer.data();

constint j_start = tabofs[range.start], j_end = tabofs[range.end];

static_assert(

}

int prev_di = -1;

int di =0;

const WT* buf_local;

WT* sum =nullptr;

for (int j = row_start; j < row_end; ++j)

{

coeff = ytab[j].alpha;

di = ytab[j].di;

si = ytab[j].si;

const T* S = src->templateptr<T>(si);

v_inter_area_copy_or_not(S, col_end, buf, &buf_local);

}

{

coeff = xtab[j].alpha;

di = xtab[j].di / cn;

si = xtab[j].si / cn;

buf_local = tmp.templateptr<WT>(si);

}

const VT v_coeff = vx_setall_local<VT>(coeff);

if (di != prev_di)

if (di != prev_di) sum = tmp.templateptr<WT>(di - start_di);

if (iter ==0)

{

sum = tmp.templateptr<WT>(di - start_di);

int x;

v_inter_area_set_sum(col_end, buf_local, v_coeff, sum, x);

for (; x < col_end; ++x) sum[x] = buf_local[x] * coeff;

prev_di = di;

const T* s = src->templateptr<T>(si);

v_inter_area_set_or_update_sum<T, WT, VT>(s, col_end, di != prev_di,

coeff, sum);

}

{

int x;

for (; x < col_end; ++x) sum[x] += buf_local[x] *coeff;

const WT* s = tmp.templateptr<WT>(si);

coeff, sum);

}

if (di != prev_di) prev_di = di;

}

WT* D = tmp.templateptr<WT>(di - start_di);

for (int x =0; x < col_end; ++x) D[x] = sum[x];

tmp =tmp(cv::Range(0, di - start_di +1),cv::Range(0, col_end / cn)).t();

}