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); }