void cv2eigen( const Mat& src,
Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& dst )
{
CV_DbgAssert(src.rows == _rows && src.cols == _cols);
if( !(dst.Flags & Eigen::RowMajorBit) )
{
Mat _dst(src.cols, src.rows, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
if( src.type() == _dst.type() )
transpose(src, _dst);
else if( src.cols == src.rows )
{
src.convertTo(_dst, _dst.type());
transpose(_dst, _dst);
}
else
Mat(src.t()).convertTo(_dst, _dst.type());
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
else
{
Mat _dst(src.rows, src.cols, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
src.convertTo(_dst, _dst.type());
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
}
template <bool align> void LbpEstimate(
const uint8_t * src, size_t srcStride, size_t width, size_t height, uint8_t * dst, size_t dstStride)
{
assert(width >= A + 2);
if(align)
assert(Aligned(src) && Aligned(srcStride));
size_t alignedWidth = AlignLo(width - 2, A) + 1;
memset(dst, 0, width);
src += srcStride;
dst += dstStride;
for (size_t row = 2; row < height; ++row)
{
dst[0] = 0;
Storer<false> _dst(dst + 1);
Store<false, true>(_dst, LbpEstimate<align>(src + 1, srcStride));
for (size_t col = A + 1; col < alignedWidth; col += A)
Store<false, false>(_dst, LbpEstimate<align>(src + col, srcStride));
Flush(_dst);
if(alignedWidth != width - 1)
Store<false>(dst + width - 1 - A, LbpEstimate<false>(src + width - 1 - A, srcStride));
dst[width - 1] = 0;
src += srcStride;
dst += dstStride;
}
memset(dst, 0, width);
}
template <bool align, bool abs> void Laplace(const uint8_t * src, size_t srcStride, size_t width, size_t height, int16_t * dst, size_t dstStride)
{
assert(width > A);
if(align)
assert(Aligned(src) && Aligned(srcStride) && Aligned(dst) && Aligned(dstStride, HA));
size_t bodyWidth = Simd::AlignHi(width, A) - A;
const uint8_t *src0, *src1, *src2;
v128_u8 a[3][3];
for(size_t row = 0; row < height; ++row)
{
src0 = src + srcStride*(row - 1);
src1 = src0 + srcStride;
src2 = src1 + srcStride;
if(row == 0)
src0 = src1;
if(row == height - 1)
src2 = src1;
Storer<align> _dst(dst);
LoadNose3<align, 1>(src0 + 0, a[0]);
LoadNose3<align, 1>(src1 + 0, a[1]);
LoadNose3<align, 1>(src2 + 0, a[2]);
Laplace<align, true, abs>(a, _dst);
for(size_t col = A; col < bodyWidth; col += A)
{
LoadBody3<align, 1>(src0 + col, a[0]);
LoadBody3<align, 1>(src1 + col, a[1]);
LoadBody3<align, 1>(src2 + col, a[2]);
Laplace<align, false, abs>(a, _dst);
}
Flush(_dst);
{
Storer<false> _dst(dst + width - A);
LoadTail3<false, 1>(src0 + width - A, a[0]);
LoadTail3<false, 1>(src1 + width - A, a[1]);
LoadTail3<false, 1>(src2 + width - A, a[2]);
Laplace<false, true, abs>(a, _dst);
Flush(_dst);
}
dst += dstStride;
}
}
void cv2eigen( const Matx<_Tp, _rows, _cols>& src,
Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& dst )
{
if( !(dst.Flags & Eigen::RowMajorBit) )
{
Mat _dst(_cols, _rows, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
transpose(src, _dst);
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
else
{
Mat _dst(_rows, _cols, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
Mat(src).copyTo(_dst);
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
}
void cv2eigen( const Matx<_Tp, 1, _cols>& src,
Eigen::Matrix<_Tp, 1, Eigen::Dynamic>& dst )
{
dst.resize(_cols);
if( !(dst.Flags & Eigen::RowMajorBit) )
{
Mat _dst(_cols, 1, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
transpose(src, _dst);
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
else
{
Mat _dst(1, _cols, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
Mat(src).copyTo(_dst);
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
}
template <bool align, size_t step> void GaussianBlur3x3(
const uint8_t * src, size_t srcStride, size_t width, size_t height, uint8_t * dst, size_t dstStride)
{
assert(step*width >= A);
if(align)
assert(Aligned(src) && Aligned(srcStride) && Aligned(step*width) && Aligned(dst) && Aligned(dstStride));
v128_u8 a[3];
size_t size = step*width;
size_t bodySize = Simd::AlignHi(size, A) - A;
Buffer buffer(Simd::AlignHi(size, A));
LoadNose3<align, step>(src + 0, a);
BlurCol<true>(a, buffer.src0 + 0);
for(size_t col = A; col < bodySize; col += A)
{
LoadBody3<align, step>(src + col, a);
BlurCol<true>(a, buffer.src0 + col);
}
LoadTail3<align, step>(src + size - A, a);
BlurCol<align>(a, buffer.src0 + size - A);
memcpy(buffer.src1, buffer.src0, sizeof(uint16_t)*size);
for(size_t row = 0; row < height; ++row, dst += dstStride)
{
const uint8_t *src2 = src + srcStride*(row + 1);
if(row >= height - 2)
src2 = src + srcStride*(height - 1);
LoadNose3<align, step>(src2 + 0, a);
BlurCol<true>(a, buffer.src2 + 0);
for(size_t col = A; col < bodySize; col += A)
{
LoadBody3<align, step>(src2 + col, a);
BlurCol<true>(a, buffer.src2 + col);
}
LoadTail3<align, step>(src2 + size - A, a);
BlurCol<align>(a, buffer.src2 + size - A);
Storer<align> _dst(dst);
_dst.First(BlurRow<true>(buffer, 0));
for(size_t col = A; col < bodySize; col += A)
_dst.Next(BlurRow<true>(buffer, col));
Flush(_dst);
Store<align>(dst + size - A, BlurRow<align>(buffer, size - A));
Swap(buffer.src0, buffer.src2);
Swap(buffer.src0, buffer.src1);
}
}
static void doBlit(Bitmap *bm, const IntRect &src, const Vec2i &dst)
{
/* Translate tile to pixel units */
IntRect _src(src.x*32, src.y*32, src.w*32, src.h*32);
Vec2i _dst(dst.x*32, dst.y*32);
IntRect bmr(0, 0, bm->width(), bm->height());
if (!SDL_IntersectRect(&_src, &bmr, &_src))
return;
GLMeta::blitRectangle(_src, _dst);
}
template<bool align> void ReduceGray2x2(const uint8_t *src, size_t srcWidth, size_t srcHeight, size_t srcStride,
uint8_t *dst, size_t dstWidth, size_t dstHeight, size_t dstStride)
{
assert((srcWidth + 1)/2 == dstWidth && (srcHeight + 1)/2 == dstHeight);
if(align)
{
assert(Aligned(src) && Aligned(srcStride));
assert(Aligned(dst) && Aligned(dstStride) && Aligned(dstWidth));
}
size_t alignedWidth = AlignLo(srcWidth, DA);
size_t evenWidth = AlignLo(srcWidth, 2);
for(size_t srcRow = 0; srcRow < srcHeight; srcRow += 2)
{
const uint8_t *src0 = src;
const uint8_t *src1 = (srcRow == srcHeight - 1 ? src : src + srcStride);
Loader<align> _src0(src0), _src1(src1);
Storer<align> _dst(dst);
Average<align, true>(_src0, _src1, _dst);
for(size_t srcOffset = DA; srcOffset < alignedWidth; srcOffset += DA)
Average<align, false>(_src0, _src1, _dst);
Flush(_dst);
if(alignedWidth != srcWidth)
{
Loader<false> _src0(src0 + evenWidth - DA), _src1(src1 + evenWidth - DA);
Storer<false> _dst(dst + dstWidth - A - (evenWidth != srcWidth ? 1 : 0));
Average<false, true>(_src0, _src1, _dst);
Flush(_dst);
if(evenWidth != srcWidth)
{
dst[dstWidth - 1] = Base::Average(src0[evenWidth], src1[evenWidth]);
}
}
src += 2*srcStride;
dst += dstStride;
}
}
template <bool align, size_t step> void MedianFilterSquare5x5(
const uint8_t * src, size_t srcStride, size_t width, size_t height, uint8_t * dst, size_t dstStride)
{
assert(step*width >= A);
const uint8_t * y[5];
v128_u8 a[25];
size_t size = step*width;
size_t bodySize = Simd::AlignHi(size, A) - A;
for(size_t row = 0; row < height; ++row, dst += dstStride)
{
y[0] = src + srcStride*(row - 2);
y[1] = y[0] + srcStride;
y[2] = y[1] + srcStride;
y[3] = y[2] + srcStride;
y[4] = y[3] + srcStride;
if(row < 2)
{
if(row < 1)
y[1] = y[2];
y[0] = y[1];
}
if(row >= height - 2)
{
if(row >= height - 1)
y[3] = y[2];
y[4] = y[3];
}
Storer<align> _dst(dst);
LoadNoseSquare5x5<align, step>(y, 0, a);
PartialSort25(a);
_dst.First(a[12]);
Store<align>(dst, a[12]);
for(size_t col = A; col < bodySize; col += A)
{
LoadBodySquare5x5<align, step>(y, col, a);
PartialSort25(a);
_dst.Next(a[12]);
}
Flush(_dst);
size_t col = size - A;
LoadTailSquare5x5<false, step>(y, col, a);
PartialSort25(a);
Store<false>(dst + col, a[12]);
}
}
void cv2eigen( const Mat& src,
Eigen::Matrix<_Tp, 1, Eigen::Dynamic>& dst )
{
CV_Assert(src.rows == 1);
dst.resize(src.cols);
if( !(dst.Flags & Eigen::RowMajorBit) )
{
Mat _dst(src.cols, src.rows, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
if( src.type() == _dst.type() )
transpose(src, _dst);
else
Mat(src.t()).convertTo(_dst, _dst.type());
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
else
{
Mat _dst(src.rows, src.cols, DataType<_Tp>::type,
dst.data(), (size_t)(dst.stride()*sizeof(_Tp)));
src.convertTo(_dst, _dst.type());
CV_DbgAssert(_dst.data == (uchar*)dst.data());
}
}
template <bool align> void FillBgr(uint8_t * dst, size_t stride, size_t width, size_t height, uint8_t blue, uint8_t green, uint8_t red)
{
if(align)
assert(Aligned(dst) && Aligned(stride));
size_t alignedWidth = AlignLo(width, A);
v128_u8 bgr0 = SIMD_VEC_SETR_EPI8(blue, green, red, blue, green, red, blue, green, red, blue, green, red, blue, green, red, blue);
v128_u8 bgr1 = SIMD_VEC_SETR_EPI8(green, red, blue, green, red, blue, green, red, blue, green, red, blue, green, red, blue, green);
v128_u8 bgr2 = SIMD_VEC_SETR_EPI8(red, blue, green, red, blue, green, red, blue, green, red, blue, green, red, blue, green, red);
for(size_t row = 0; row < height; ++row)
{
Storer<align> _dst(dst);
Store<align, true>(_dst, bgr0);
Store<align, false>(_dst, bgr1);
Store<align, false>(_dst, bgr2);
for(size_t col = A; col < alignedWidth; col += A)
{
Store<align, false>(_dst, bgr0);
Store<align, false>(_dst, bgr1);
Store<align, false>(_dst, bgr2);
}
Flush(_dst);
if(alignedWidth != width)
{
Storer<false> _dst(dst + (width - A)*3);
Store<false, true>(_dst, bgr0);
Store<false, false>(_dst, bgr1);
Store<false, false>(_dst, bgr2);
Flush(_dst);
}
dst += stride;
}
}
template<bool align, bool compensation> void ReduceGray3x3(
const uint8_t* src, size_t srcWidth, size_t srcHeight, size_t srcStride,
uint8_t* dst, size_t dstWidth, size_t dstHeight, size_t dstStride)
{
assert(srcWidth >= DA && (srcWidth + 1)/2 == dstWidth && (srcHeight + 1)/2 == dstHeight);
if(align)
assert(Aligned(src) && Aligned(srcStride) && Aligned(dst) && Aligned(dstStride));
size_t lastOddCol = srcWidth - AlignLo(srcWidth, 2);
size_t bodyWidth = AlignLo(srcWidth, DA);
for(size_t row = 0; row < srcHeight; row += 2, dst += dstStride, src += 2*srcStride)
{
const uint8_t * s[3];
s[1] = src;
s[0] = s[1] - (row ? srcStride : 0);
s[2] = s[1] + (row != srcHeight - 1 ? srcStride : 0);
Storer<align> _dst(dst);
v128_u16 lo[3], hi[3];
ReduceColNose<align>(s, lo);
ReduceColBody<align>(s, A, hi);
Store<align, true>(_dst, ReduceRow<compensation>(lo, hi));
for(size_t srcCol = DA, dstCol = A; srcCol < bodyWidth; srcCol += DA)
{
ReduceColBody<align>(s, srcCol, lo);
ReduceColBody<align>(s, srcCol + A, hi);
Store<align, false>(_dst, ReduceRow<compensation>(lo, hi));
}
Flush(_dst);
if(bodyWidth != srcWidth)
{
size_t srcCol = srcWidth - DA - lastOddCol;
size_t dstCol = dstWidth - A - lastOddCol;
ReduceColBody<false>(s, srcCol, lo);
ReduceColBody<false>(s, srcCol + A, hi);
Store<false>(dst + dstCol, ReduceRow<compensation>(lo, hi));
if(lastOddCol)
dst[dstWidth - 1] = Base::GaussianBlur3x3<compensation>(s[0] + srcWidth, s[1]+ srcWidth, s[2] + srcWidth, -2, -1, -1);
}
}
}
template<bool align> void AbsGradientSaturatedSum(const uint8_t * src, size_t srcStride, size_t width, size_t height, uint8_t * dst, size_t dstStride)
{
size_t alignedWidth = AlignLo(width, A);
size_t fullAlignedWidth = AlignLo(width, QA);
memset(dst, 0, width);
src += srcStride;
dst += dstStride;
for (size_t row = 2; row < height; ++row)
{
if(align)
{
size_t col = 0;
for (; col < fullAlignedWidth; col += QA)
{
AbsGradientSaturatedSum<align>(src, srcStride, dst, col);
AbsGradientSaturatedSum<align>(src, srcStride, dst, col + A);
AbsGradientSaturatedSum<align>(src, srcStride, dst, col + 2*A);
AbsGradientSaturatedSum<align>(src, srcStride, dst, col + 3*A);
}
for (; col < alignedWidth; col += A)
AbsGradientSaturatedSum<align>(src, srcStride, dst, col);
}
else
{
Storer<align> _dst(dst);
_dst.First(AbsGradientSaturatedSum<align>(src, srcStride));
for (size_t col = A; col < alignedWidth; col += A)
_dst.Next(AbsGradientSaturatedSum<align>(src + col, srcStride));
Flush(_dst);
}
if(width != alignedWidth)
AbsGradientSaturatedSum<false>(src, srcStride, dst, width - A);
dst[0] = 0;
dst[width - 1] = 0;
src += srcStride;
dst += dstStride;
}
memset(dst, 0, width);
}
template <bool align> void FillBgra(uint8_t * dst, size_t stride, size_t width, size_t height, uint8_t blue, uint8_t green, uint8_t red, uint8_t alpha)
{
if(align)
assert(Aligned(dst) && Aligned(stride));
uint32_t bgra32 = uint32_t(alpha) | (uint32_t(red) << 8) | (uint32_t(green) << 16) | (uint32_t(blue) << 24);
size_t alignedWidth = AlignLo(width, 4);
v128_u8 bgra128 = (v128_u8)SetU32(bgra32);
for(size_t row = 0; row < height; ++row)
{
Storer<align> _dst(dst);
Store<align, true>(_dst, bgra128);
for(size_t col = 4; col < alignedWidth; col += 4)
Store<align, false>(_dst, bgra128);
Flush(_dst);
if(width != alignedWidth)
Store<false>(dst + 4*(width - 4), bgra128);
dst += stride;
}
}
static void tst_shl_rand(unsynch_mpz_manager & m, unsigned sz, unsigned k, bool trace = true) {
// create a random bitvector of of size sz
svector<unsigned> src;
for (unsigned i = 0; i < sz; i++) {
src.push_back(rand());
}
// convert src into a mpz number
scoped_mpz _src(m);
scoped_mpz tmp(m);
unsigned i = sz;
while (i > 0) {
--i;
m.mul2k(_src, 32);
m.set(tmp, src[i]);
m.add(_src, tmp, _src);
}
// shift left by multiplying by 2^k
scoped_mpz _dst(m);
m.set(_dst, _src);
m.mul2k(_dst, k);
// convert _dst into a vector of unsigned values
svector<unsigned> dst;
scoped_mpz max(m);
m.set(max, 1);
m.mul2k(max, 32);
while (!m.is_zero(_dst)) {
m.mod(_dst, max, tmp);
ENSURE(m.is_uint64(tmp) && m.get_uint64(tmp) < UINT_MAX);
dst.push_back(static_cast<unsigned>(m.get_uint64(tmp)));
m.div(_dst, max, _dst);
}
while (dst.size() < src.size())
dst.push_back(0);
dst.push_back(0);
unsigned word_shift = (k / 32);
for (unsigned i = 0; i < word_shift; i++)
dst.push_back(0);
tst_shl(src.size(), src.c_ptr(), k, dst.size(), dst.c_ptr(), trace);
}
