GPU_PERF_TEST_1(BroxOpticalFlow, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, \r
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
\r
+ d_flow(frame0, frame1, u, v);\r
+\r
declare.time(10);\r
\r
TEST_CYCLE()\r
GPU_PERF_TEST_1(InterpolateFrames, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
cv::gpu::GpuMat newFrame;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);\r
GPU_PERF_TEST_1(CreateOpticalFlowNeedleMap, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
\r
cv::gpu::GpuMat vertex, colors;\r
\r
+ cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);\r
//////////////////////////////////////////////////////\r
// GoodFeaturesToTrack\r
\r
-GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, double)\r
+IMPLEMENT_PARAM_CLASS(MinDistance, double)\r
+\r
+GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- double minDistance = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat image_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ double minDistance = GET_PARAM(1);\r
\r
+ cv::Mat image_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(image_host.empty());\r
\r
cv::gpu::GoodFeaturesToTrackDetector_GPU detector(8000, 0.01, minDistance);\r
cv::gpu::GpuMat image(image_host);\r
cv::gpu::GpuMat pts;\r
\r
+ detector(image, pts);\r
+\r
TEST_CYCLE()\r
{\r
detector(image, pts);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(ALL_DEVICES, testing::Values(0.0, 3.0)));\r
+INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(MinDistance(0.0), MinDistance(3.0))));\r
\r
//////////////////////////////////////////////////////\r
// PyrLKOpticalFlowSparse\r
\r
+IMPLEMENT_PARAM_CLASS(GraySource, bool)\r
+IMPLEMENT_PARAM_CLASS(Points, int)\r
IMPLEMENT_PARAM_CLASS(WinSize, int)\r
+IMPLEMENT_PARAM_CLASS(Levels, int)\r
+IMPLEMENT_PARAM_CLASS(Iters, int)\r
\r
-GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, bool, int, int)\r
+GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, GraySource, Points, WinSize, Levels, Iters)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
bool useGray = GET_PARAM(1);\r
int points = GET_PARAM(2);\r
- int win_size = GET_PARAM(3);\r
+ int winSize = GET_PARAM(3);\r
+ int levels = GET_PARAM(4);\r
+ int iters = GET_PARAM(5);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
- \r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::Mat gray_frame;\r
detector(cv::gpu::GpuMat(gray_frame), pts);\r
\r
cv::gpu::PyrLKOpticalFlow pyrLK;\r
- pyrLK.winSize = cv::Size(win_size, win_size);\r
+ pyrLK.winSize = cv::Size(winSize, winSize);\r
+ pyrLK.maxLevel = levels - 1;\r
+ pyrLK.iters = iters;\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat frame1(frame1_host);\r
cv::gpu::GpuMat nextPts;\r
cv::gpu::GpuMat status;\r
\r
+ pyrLK.sparse(frame0, frame1, pts, nextPts, status);\r
+\r
TEST_CYCLE()\r
{\r
pyrLK.sparse(frame0, frame1, pts, nextPts, status);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine\r
- (\r
- ALL_DEVICES, \r
- testing::Bool(), \r
- testing::Values(1000, 2000, 4000, 8000), \r
- testing::Values(17, 21)\r
- ));\r
+INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(GraySource(true), GraySource(false)),\r
+ testing::Values(Points(1000), Points(2000), Points(4000), Points(8000)),\r
+ testing::Values(WinSize(9), WinSize(13), WinSize(17), WinSize(21)),\r
+ testing::Values(Levels(1), Levels(2), Levels(3)),\r
+ testing::Values(Iters(1), Iters(10), Iters(30))));\r
\r
//////////////////////////////////////////////////////\r
// PyrLKOpticalFlowDense\r
\r
-IMPLEMENT_PARAM_CLASS(Levels, int)\r
-IMPLEMENT_PARAM_CLASS(Iters, int)\r
-\r
GPU_PERF_TEST(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo, WinSize, Levels, Iters)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
int winSize = GET_PARAM(1);\r
int iters = GET_PARAM(3);\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
testing::Values(Levels(1), Levels(2), Levels(3)),\r
testing::Values(Iters(1), Iters(10))));\r
\r
-\r
//////////////////////////////////////////////////////\r
// FarnebackOpticalFlowTest\r
\r
GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat u;\r
cv::gpu::GpuMat v;\r
\r
- cv::gpu::FarnebackOpticalFlow calc;\r
+ cv::gpu::FarnebackOpticalFlow farneback;\r
+\r
+ farneback(frame0, frame1, u, v);\r
\r
declare.time(10);\r
\r
TEST_CYCLE()\r
{\r
- calc(frame0, frame1, u, v);\r
+ farneback(frame0, frame1, u, v);\r
}\r
}\r
\r
#include "opencv2/gpu/device/utility.hpp"\r
#include "opencv2/gpu/device/functional.hpp"\r
#include "opencv2/gpu/device/limits.hpp"\r
+#include "opencv2/gpu/device/vec_math.hpp"\r
\r
namespace cv { namespace gpu { namespace device\r
{\r
namespace pyrlk\r
{\r
- __constant__ int c_cn;\r
- __constant__ float c_minEigThreshold;\r
__constant__ int c_winSize_x;\r
__constant__ int c_winSize_y;\r
- __constant__ int c_winSize_x_cn;\r
+\r
__constant__ int c_halfWin_x;\r
__constant__ int c_halfWin_y;\r
+\r
__constant__ int c_iters;\r
\r
- void loadConstants(int cn, float minEigThreshold, int2 winSize, int iters)\r
+ void loadConstants(int2 winSize, int iters)\r
{\r
- int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);\r
- cudaSafeCall( cudaMemcpyToSymbol(c_cn, &cn, sizeof(int)) );\r
- cudaSafeCall( cudaMemcpyToSymbol(c_minEigThreshold, &minEigThreshold, sizeof(float)) );\r
cudaSafeCall( cudaMemcpyToSymbol(c_winSize_x, &winSize.x, sizeof(int)) );\r
cudaSafeCall( cudaMemcpyToSymbol(c_winSize_y, &winSize.y, sizeof(int)) );\r
- winSize.x *= cn;\r
- cudaSafeCall( cudaMemcpyToSymbol(c_winSize_x_cn, &winSize.x, sizeof(int)) );\r
+\r
+ int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);\r
cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_x, &halfWin.x, sizeof(int)) );\r
cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_y, &halfWin.y, sizeof(int)) );\r
- cudaSafeCall( cudaMemcpyToSymbol(c_iters, &iters, sizeof(int)) );\r
- }\r
-\r
- __global__ void calcSharrDeriv_vertical(const PtrStepb src, PtrStep<short> dx_buf, PtrStep<short> dy_buf, int rows, int colsn)\r
- {\r
- const int x = blockIdx.x * blockDim.x + threadIdx.x;\r
- const int y = blockIdx.y * blockDim.y + threadIdx.y;\r
-\r
- if (y < rows && x < colsn)\r
- {\r
- const uchar src_val0 = src(y > 0 ? y - 1 : 1, x);\r
- const uchar src_val1 = src(y, x);\r
- const uchar src_val2 = src(y < rows - 1 ? y + 1 : rows - 2, x);\r
-\r
- dx_buf(y, x) = (src_val0 + src_val2) * 3 + src_val1 * 10;\r
- dy_buf(y, x) = src_val2 - src_val0;\r
- }\r
- }\r
-\r
- __global__ void calcSharrDeriv_horizontal(const PtrStep<short> dx_buf, const PtrStep<short> dy_buf, PtrStep<short> dIdx, PtrStep<short> dIdy, int rows, int cols)\r
- {\r
- const int x = blockIdx.x * blockDim.x + threadIdx.x;\r
- const int y = blockIdx.y * blockDim.y + threadIdx.y;\r
-\r
- const int colsn = cols * c_cn;\r
-\r
- if (y < rows && x < colsn)\r
- {\r
- const short* dx_buf_row = dx_buf.ptr(y);\r
- const short* dy_buf_row = dy_buf.ptr(y);\r
-\r
- const int xr = x + c_cn < colsn ? x + c_cn : (cols - 2) * c_cn + x + c_cn - colsn;\r
- const int xl = x - c_cn >= 0 ? x - c_cn : c_cn + x;\r
-\r
- dIdx(y, x) = dx_buf_row[xr] - dx_buf_row[xl];\r
- dIdy(y, x) = (dy_buf_row[xr] + dy_buf_row[xl]) * 3 + dy_buf_row[x] * 10;\r
- }\r
- }\r
-\r
- void calcSharrDeriv_gpu(DevMem2Db src, DevMem2D_<short> dx_buf, DevMem2D_<short> dy_buf, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy, int cn,\r
- cudaStream_t stream)\r
- {\r
- dim3 block(32, 8);\r
- dim3 grid(divUp(src.cols * cn, block.x), divUp(src.rows, block.y));\r
-\r
- calcSharrDeriv_vertical<<<grid, block, 0, stream>>>(src, dx_buf, dy_buf, src.rows, src.cols * cn);\r
- cudaSafeCall( cudaGetLastError() );\r
-\r
- calcSharrDeriv_horizontal<<<grid, block, 0, stream>>>(dx_buf, dy_buf, dIdx, dIdy, src.rows, src.cols);\r
- cudaSafeCall( cudaGetLastError() );\r
-\r
- if (stream == 0)\r
- cudaSafeCall( cudaDeviceSynchronize() );\r
- }\r
-\r
- #define W_BITS 14\r
- #define W_BITS1 14\r
-\r
- #define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))\r
\r
- __device__ int linearFilter(const PtrStepb& src, float2 pt, int x, int y)\r
- {\r
- int2 ipt;\r
- ipt.x = __float2int_rd(pt.x);\r
- ipt.y = __float2int_rd(pt.y);\r
-\r
- float a = pt.x - ipt.x;\r
- float b = pt.y - ipt.y;\r
-\r
- int iw00 = __float2int_rn((1.0f - a) * (1.0f - b) * (1 << W_BITS));\r
- int iw01 = __float2int_rn(a * (1.0f - b) * (1 << W_BITS));\r
- int iw10 = __float2int_rn((1.0f - a) * b * (1 << W_BITS));\r
- int iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;\r
-\r
- const uchar* src_row = src.ptr(ipt.y + y) + ipt.x * c_cn;\r
- const uchar* src_row1 = src.ptr(ipt.y + y + 1) + ipt.x * c_cn;\r
-\r
- return CV_DESCALE(src_row[x] * iw00 + src_row[x + c_cn] * iw01 + src_row1[x] * iw10 + src_row1[x + c_cn] * iw11, W_BITS1 - 5);\r
- }\r
-\r
- __device__ int linearFilter(const PtrStep<short>& src, float2 pt, int x, int y)\r
- {\r
- int2 ipt;\r
- ipt.x = __float2int_rd(pt.x);\r
- ipt.y = __float2int_rd(pt.y);\r
-\r
- float a = pt.x - ipt.x;\r
- float b = pt.y - ipt.y;\r
-\r
- int iw00 = __float2int_rn((1.0f - a) * (1.0f - b) * (1 << W_BITS));\r
- int iw01 = __float2int_rn(a * (1.0f - b) * (1 << W_BITS));\r
- int iw10 = __float2int_rn((1.0f - a) * b * (1 << W_BITS));\r
- int iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;\r
-\r
- const short* src_row = src.ptr(ipt.y + y) + ipt.x * c_cn;\r
- const short* src_row1 = src.ptr(ipt.y + y + 1) + ipt.x * c_cn;\r
-\r
- return CV_DESCALE(src_row[x] * iw00 + src_row[x + c_cn] * iw01 + src_row1[x] * iw10 + src_row1[x + c_cn] * iw11, W_BITS1);\r
+ cudaSafeCall( cudaMemcpyToSymbol(c_iters, &iters, sizeof(int)) );\r
}\r
\r
__device__ void reduce(float& val1, float& val2, float& val3, float* smem1, float* smem2, float* smem3, int tid)\r
}\r
}\r
\r
- #define SCALE (1.0f / (1 << 20))\r
+ texture<float, cudaTextureType2D, cudaReadModeElementType> tex_If(false, cudaFilterModeLinear, cudaAddressModeClamp);\r
+ texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_If4(false, cudaFilterModeLinear, cudaAddressModeClamp);\r
+ texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_Ib(false, cudaFilterModePoint, cudaAddressModeClamp);\r
+\r
+ texture<float, cudaTextureType2D, cudaReadModeElementType> tex_Jf(false, cudaFilterModeLinear, cudaAddressModeClamp);\r
+ texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_Jf4(false, cudaFilterModeLinear, cudaAddressModeClamp);\r
+\r
+ template <int cn> struct Tex_I;\r
+ template <> struct Tex_I<1>\r
+ {\r
+ static __device__ __forceinline__ float read(float x, float y)\r
+ {\r
+ return tex2D(tex_If, x, y);\r
+ }\r
+ };\r
+ template <> struct Tex_I<4>\r
+ {\r
+ static __device__ __forceinline__ float4 read(float x, float y)\r
+ {\r
+ return tex2D(tex_If4, x, y);\r
+ }\r
+ };\r
+\r
+ template <int cn> struct Tex_J;\r
+ template <> struct Tex_J<1>\r
+ {\r
+ static __device__ __forceinline__ float read(float x, float y)\r
+ {\r
+ return tex2D(tex_Jf, x, y);\r
+ }\r
+ };\r
+ template <> struct Tex_J<4>\r
+ {\r
+ static __device__ __forceinline__ float4 read(float x, float y)\r
+ {\r
+ return tex2D(tex_Jf4, x, y);\r
+ }\r
+ };\r
+\r
+ __device__ __forceinline__ void accum(float& dst, float val)\r
+ {\r
+ dst += val;\r
+ }\r
+ __device__ __forceinline__ void accum(float& dst, const float4& val)\r
+ {\r
+ dst += val.x + val.y + val.z;\r
+ }\r
+\r
+ __device__ __forceinline__ float abs_(float a)\r
+ {\r
+ return ::fabs(a);\r
+ }\r
+ __device__ __forceinline__ float4 abs_(const float4& a)\r
+ {\r
+ return fabs(a);\r
+ }\r
\r
- template <int PATCH_X, int PATCH_Y, bool calcErr, bool GET_MIN_EIGENVALS>\r
- __global__ void lkSparse(const PtrStepb I, const PtrStepb J, const PtrStep<short> dIdx, const PtrStep<short> dIdy,\r
- const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)\r
+ template <int cn, int PATCH_X, int PATCH_Y, bool calcErr>\r
+ __global__ void lkSparse(const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)\r
{\r
#if __CUDA_ARCH__ <= 110\r
__shared__ float smem1[128];\r
prevPt.x *= (1.0f / (1 << level));\r
prevPt.y *= (1.0f / (1 << level));\r
\r
- prevPt.x -= c_halfWin_x;\r
- prevPt.y -= c_halfWin_y;\r
-\r
- if (prevPt.x < -c_winSize_x || prevPt.x >= cols || prevPt.y < -c_winSize_y || prevPt.y >= rows)\r
+ if (prevPt.x < 0 || prevPt.x >= cols || prevPt.y < 0 || prevPt.y >= rows)\r
{\r
- if (level == 0 && tid == 0)\r
- {\r
+ if (tid == 0 && level == 0)\r
status[blockIdx.x] = 0;\r
\r
- if (calcErr)\r
- err[blockIdx.x] = 0;\r
- }\r
-\r
return;\r
}\r
\r
+ prevPt.x -= c_halfWin_x;\r
+ prevPt.y -= c_halfWin_y;\r
+\r
// extract the patch from the first image, compute covariation matrix of derivatives\r
\r
float A11 = 0;\r
float A12 = 0;\r
float A22 = 0;\r
\r
- int I_patch[PATCH_Y][PATCH_X];\r
- int dIdx_patch[PATCH_Y][PATCH_X];\r
- int dIdy_patch[PATCH_Y][PATCH_X];\r
+ typedef typename TypeVec<float, cn>::vec_type work_type;\r
+\r
+ work_type I_patch [PATCH_Y][PATCH_X];\r
+ work_type dIdx_patch[PATCH_Y][PATCH_X];\r
+ work_type dIdy_patch[PATCH_Y][PATCH_X];\r
\r
- for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)\r
+ for (int yBase = threadIdx.y, i = 0; yBase < c_winSize_y; yBase += blockDim.y, ++i)\r
{\r
- for (int x = threadIdx.x, j = 0; x < c_winSize_x_cn; x += blockDim.x, ++j)\r
+ for (int xBase = threadIdx.x, j = 0; xBase < c_winSize_x; xBase += blockDim.x, ++j)\r
{\r
- I_patch[i][j] = linearFilter(I, prevPt, x, y);\r
+ float x = prevPt.x + xBase + 0.5f;\r
+ float y = prevPt.y + yBase + 0.5f;\r
+\r
+ I_patch[i][j] = Tex_I<cn>::read(x, y);\r
+\r
+ // Sharr Deriv\r
+\r
+ work_type dIdx = 3.0f * Tex_I<cn>::read(x+1, y-1) + 10.0f * Tex_I<cn>::read(x+1, y) + 3.0f * Tex_I<cn>::read(x+1, y+1) -\r
+ (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x-1, y) + 3.0f * Tex_I<cn>::read(x-1, y+1));\r
\r
- int ixval = linearFilter(dIdx, prevPt, x, y);\r
- int iyval = linearFilter(dIdy, prevPt, x, y);\r
+ work_type dIdy = 3.0f * Tex_I<cn>::read(x-1, y+1) + 10.0f * Tex_I<cn>::read(x, y+1) + 3.0f * Tex_I<cn>::read(x+1, y+1) -\r
+ (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x, y-1) + 3.0f * Tex_I<cn>::read(x+1, y-1));\r
\r
- dIdx_patch[i][j] = ixval;\r
- dIdy_patch[i][j] = iyval;\r
+ dIdx_patch[i][j] = dIdx;\r
+ dIdy_patch[i][j] = dIdy;\r
\r
- A11 += ixval * ixval;\r
- A12 += ixval * iyval;\r
- A22 += iyval * iyval;\r
+ accum(A11, dIdx * dIdx);\r
+ accum(A12, dIdx * dIdy);\r
+ accum(A22, dIdy * dIdy);\r
}\r
}\r
\r
A12 = smem2[0];\r
A22 = smem3[0];\r
\r
- A11 *= SCALE;\r
- A12 *= SCALE;\r
- A22 *= SCALE;\r
+ float D = A11 * A22 - A12 * A12;\r
\r
+ if (D < numeric_limits<float>::epsilon())\r
{\r
- float D = A11 * A22 - A12 * A12;\r
- float minEig = (A22 + A11 - ::sqrtf((A11 - A22) * (A11 - A22) + 4.f * A12 * A12)) / (2 * c_winSize_x * c_winSize_y);\r
-\r
- if (calcErr && GET_MIN_EIGENVALS && tid == 0)\r
- err[blockIdx.x] = minEig;\r
-\r
- if (minEig < c_minEigThreshold || D < numeric_limits<float>::epsilon())\r
- {\r
- if (level == 0 && tid == 0)\r
- status[blockIdx.x] = 0;\r
+ if (tid == 0 && level == 0)\r
+ status[blockIdx.x] = 0;\r
\r
- return;\r
- }\r
+ return;\r
+ }\r
\r
- D = 1.f / D;\r
+ D = 1.f / D;\r
\r
- A11 *= D;\r
- A12 *= D;\r
- A22 *= D;\r
- }\r
+ A11 *= D;\r
+ A12 *= D;\r
+ A22 *= D;\r
\r
float2 nextPt = nextPts[blockIdx.x];\r
nextPt.x *= 2.f;\r
nextPt.x -= c_halfWin_x;\r
nextPt.y -= c_halfWin_y;\r
\r
- bool status_ = true;\r
-\r
for (int k = 0; k < c_iters; ++k)\r
{\r
- if (nextPt.x < -c_winSize_x || nextPt.x >= cols || nextPt.y < -c_winSize_y || nextPt.y >= rows)\r
+ if (nextPt.x < -c_halfWin_x || nextPt.x >= cols || nextPt.y < -c_halfWin_y || nextPt.y >= rows)\r
{\r
- status_ = false;\r
- break;\r
+ if (tid == 0 && level == 0)\r
+ status[blockIdx.x] = 0;\r
+\r
+ return;\r
}\r
\r
float b1 = 0;\r
\r
for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)\r
{\r
- for (int x = threadIdx.x, j = 0; x < c_winSize_x_cn; x += blockDim.x, ++j)\r
+ for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)\r
{\r
- int diff = linearFilter(J, nextPt, x, y) - I_patch[i][j];\r
+ work_type I_val = I_patch[i][j];\r
+ work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);\r
+\r
+ work_type diff = (J_val - I_val) * 32.0f;\r
\r
- b1 += diff * dIdx_patch[i][j];\r
- b2 += diff * dIdy_patch[i][j];\r
+ accum(b1, diff * dIdx_patch[i][j]);\r
+ accum(b2, diff * dIdy_patch[i][j]);\r
}\r
}\r
\r
b1 = smem1[0];\r
b2 = smem2[0];\r
\r
- b1 *= SCALE;\r
- b2 *= SCALE;\r
-\r
float2 delta;\r
delta.x = A12 * b2 - A22 * b1;\r
delta.y = A12 * b1 - A11 * b2;\r
break;\r
}\r
\r
- if (nextPt.x < -c_winSize_x || nextPt.x >= cols || nextPt.y < -c_winSize_y || nextPt.y >= rows)\r
- status_ = false;\r
-\r
- float errval = 0.f;\r
- if (calcErr && !GET_MIN_EIGENVALS && status_)\r
+ float errval = 0;\r
+ if (calcErr)\r
{\r
for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)\r
{\r
- for (int x = threadIdx.x, j = 0; x < c_winSize_x_cn; x += blockDim.x, ++j)\r
+ for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)\r
{\r
- int diff = linearFilter(J, nextPt, x, y) - I_patch[i][j];\r
- errval += ::fabsf((float)diff);\r
+ work_type I_val = I_patch[i][j];\r
+ work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);\r
+\r
+ work_type diff = J_val - I_val;\r
+\r
+ accum(errval, abs_(diff));\r
}\r
}\r
\r
reduce(errval, smem1, tid);\r
-\r
- errval /= 32 * c_winSize_x_cn * c_winSize_y;\r
}\r
\r
if (tid == 0)\r
nextPt.x += c_halfWin_x;\r
nextPt.y += c_halfWin_y;\r
\r
- status[blockIdx.x] = status_;\r
nextPts[blockIdx.x] = nextPt;\r
\r
- if (calcErr && !GET_MIN_EIGENVALS)\r
- err[blockIdx.x] = errval;\r
+ if (calcErr)\r
+ err[blockIdx.x] = static_cast<float>(errval) / (cn * c_winSize_x * c_winSize_y);\r
}\r
}\r
\r
- template <int PATCH_X, int PATCH_Y>\r
- void lkSparse_caller(DevMem2Db I, DevMem2Db J, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy,\r
- const float2* prevPts, float2* nextPts, uchar* status, float* err, bool GET_MIN_EIGENVALS, int ptcount,\r
+ template <int cn, int PATCH_X, int PATCH_Y>\r
+ void lkSparse_caller(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
int level, dim3 block, cudaStream_t stream)\r
{\r
dim3 grid(ptcount);\r
\r
if (level == 0 && err)\r
- {\r
- if (GET_MIN_EIGENVALS)\r
- {\r
- cudaSafeCall( cudaFuncSetCacheConfig(lkSparse<PATCH_X, PATCH_Y, true, true>, cudaFuncCachePreferL1) );\r
-\r
- lkSparse<PATCH_X, PATCH_Y, true, true><<<grid, block>>>(I, J, dIdx, dIdy,\r
- prevPts, nextPts, status, err, level, I.rows, I.cols);\r
- }\r
- else\r
- {\r
- cudaSafeCall( cudaFuncSetCacheConfig(lkSparse<PATCH_X, PATCH_Y, true, false>, cudaFuncCachePreferL1) );\r
-\r
- lkSparse<PATCH_X, PATCH_Y, true, false><<<grid, block>>>(I, J, dIdx, dIdy,\r
- prevPts, nextPts, status, err, level, I.rows, I.cols);\r
- }\r
- }\r
+ lkSparse<cn, PATCH_X, PATCH_Y, true><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);\r
else\r
- {\r
- cudaSafeCall( cudaFuncSetCacheConfig(lkSparse<PATCH_X, PATCH_Y, false, false>, cudaFuncCachePreferL1) );\r
-\r
- lkSparse<PATCH_X, PATCH_Y, false, false><<<grid, block>>>(I, J, dIdx, dIdy,\r
- prevPts, nextPts, status, err, level, I.rows, I.cols);\r
- }\r
+ lkSparse<cn, PATCH_X, PATCH_Y, false><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);\r
\r
cudaSafeCall( cudaGetLastError() );\r
\r
cudaSafeCall( cudaDeviceSynchronize() );\r
}\r
\r
- void lkSparse_gpu(DevMem2Db I, DevMem2Db J, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy,\r
- const float2* prevPts, float2* nextPts, uchar* status, float* err, bool GET_MIN_EIGENVALS, int ptcount,\r
+ void lkSparse1_gpu(DevMem2Df I, DevMem2Df J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
int level, dim3 block, dim3 patch, cudaStream_t stream)\r
{\r
- typedef void (*func_t)(DevMem2Db I, DevMem2Db J, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy,\r
- const float2* prevPts, float2* nextPts, uchar* status, float* err, bool GET_MIN_EIGENVALS, int ptcount,\r
+ typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
int level, dim3 block, cudaStream_t stream);\r
\r
static const func_t funcs[5][5] =\r
{\r
- {lkSparse_caller<1, 1>, lkSparse_caller<2, 1>, lkSparse_caller<3, 1>, lkSparse_caller<4, 1>, lkSparse_caller<5, 1>},\r
- {lkSparse_caller<1, 2>, lkSparse_caller<2, 2>, lkSparse_caller<3, 2>, lkSparse_caller<4, 2>, lkSparse_caller<5, 2>},\r
- {lkSparse_caller<1, 3>, lkSparse_caller<2, 3>, lkSparse_caller<3, 3>, lkSparse_caller<4, 3>, lkSparse_caller<5, 3>},\r
- {lkSparse_caller<1, 4>, lkSparse_caller<2, 4>, lkSparse_caller<3, 4>, lkSparse_caller<4, 4>, lkSparse_caller<5, 4>},\r
- {lkSparse_caller<1, 5>, lkSparse_caller<2, 5>, lkSparse_caller<3, 5>, lkSparse_caller<4, 5>, lkSparse_caller<5, 5>}\r
+ {lkSparse_caller<1, 1, 1>, lkSparse_caller<1, 2, 1>, lkSparse_caller<1, 3, 1>, lkSparse_caller<1, 4, 1>, lkSparse_caller<1, 5, 1>},\r
+ {lkSparse_caller<1, 1, 2>, lkSparse_caller<1, 2, 2>, lkSparse_caller<1, 3, 2>, lkSparse_caller<1, 4, 2>, lkSparse_caller<1, 5, 2>},\r
+ {lkSparse_caller<1, 1, 3>, lkSparse_caller<1, 2, 3>, lkSparse_caller<1, 3, 3>, lkSparse_caller<1, 4, 3>, lkSparse_caller<1, 5, 3>},\r
+ {lkSparse_caller<1, 1, 4>, lkSparse_caller<1, 2, 4>, lkSparse_caller<1, 3, 4>, lkSparse_caller<1, 4, 4>, lkSparse_caller<1, 5, 4>},\r
+ {lkSparse_caller<1, 1, 5>, lkSparse_caller<1, 2, 5>, lkSparse_caller<1, 3, 5>, lkSparse_caller<1, 4, 5>, lkSparse_caller<1, 5, 5>}\r
};\r
\r
- funcs[patch.y - 1][patch.x - 1](I, J, dIdx, dIdy,\r
- prevPts, nextPts, status, err, GET_MIN_EIGENVALS, ptcount,\r
+ bindTexture(&tex_If, I);\r
+ bindTexture(&tex_Jf, J);\r
+\r
+ funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,\r
level, block, stream);\r
}\r
\r
- texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_I(false, cudaFilterModePoint, cudaAddressModeClamp);\r
- texture<float, cudaTextureType2D, cudaReadModeElementType> tex_J(false, cudaFilterModeLinear, cudaAddressModeClamp);\r
+ void lkSparse4_gpu(DevMem2D_<float4> I, DevMem2D_<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
+ int level, dim3 block, dim3 patch, cudaStream_t stream)\r
+ {\r
+ typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
+ int level, dim3 block, cudaStream_t stream);\r
+\r
+ static const func_t funcs[5][5] =\r
+ {\r
+ {lkSparse_caller<4, 1, 1>, lkSparse_caller<4, 2, 1>, lkSparse_caller<4, 3, 1>, lkSparse_caller<4, 4, 1>, lkSparse_caller<4, 5, 1>},\r
+ {lkSparse_caller<4, 1, 2>, lkSparse_caller<4, 2, 2>, lkSparse_caller<4, 3, 2>, lkSparse_caller<4, 4, 2>, lkSparse_caller<4, 5, 2>},\r
+ {lkSparse_caller<4, 1, 3>, lkSparse_caller<4, 2, 3>, lkSparse_caller<4, 3, 3>, lkSparse_caller<4, 4, 3>, lkSparse_caller<4, 5, 3>},\r
+ {lkSparse_caller<4, 1, 4>, lkSparse_caller<4, 2, 4>, lkSparse_caller<4, 3, 4>, lkSparse_caller<4, 4, 4>, lkSparse_caller<4, 5, 4>},\r
+ {lkSparse_caller<4, 1, 5>, lkSparse_caller<4, 2, 5>, lkSparse_caller<4, 3, 5>, lkSparse_caller<4, 4, 5>, lkSparse_caller<4, 5, 5>}\r
+ };\r
+\r
+ bindTexture(&tex_If4, I);\r
+ bindTexture(&tex_Jf4, J);\r
+\r
+ funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,\r
+ level, block, stream);\r
+ }\r
\r
template <bool calcErr>\r
__global__ void lkDense(PtrStepf u, PtrStepf v, const PtrStepf prevU, const PtrStepf prevV, PtrStepf err, const int rows, const int cols)\r
float x = xBase - c_halfWin_x + j + 0.5f;\r
float y = yBase - c_halfWin_y + i + 0.5f;\r
\r
- I_patch[i * patchWidth + j] = tex2D(tex_I, x, y);\r
+ I_patch[i * patchWidth + j] = tex2D(tex_Ib, x, y);\r
\r
// Sharr Deriv\r
\r
- dIdx_patch[i * patchWidth + j] = 3 * tex2D(tex_I, x+1, y-1) + 10 * tex2D(tex_I, x+1, y) + 3 * tex2D(tex_I, x+1, y+1) -\r
- (3 * tex2D(tex_I, x-1, y-1) + 10 * tex2D(tex_I, x-1, y) + 3 * tex2D(tex_I, x-1, y+1));\r
+ dIdx_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x+1, y-1) + 10 * tex2D(tex_Ib, x+1, y) + 3 * tex2D(tex_Ib, x+1, y+1) -\r
+ (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x-1, y) + 3 * tex2D(tex_Ib, x-1, y+1));\r
\r
- dIdy_patch[i * patchWidth + j] = 3 * tex2D(tex_I, x-1, y+1) + 10 * tex2D(tex_I, x, y+1) + 3 * tex2D(tex_I, x+1, y+1) -\r
- (3 * tex2D(tex_I, x-1, y-1) + 10 * tex2D(tex_I, x, y-1) + 3 * tex2D(tex_I, x+1, y-1));\r
+ dIdy_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x-1, y+1) + 10 * tex2D(tex_Ib, x, y+1) + 3 * tex2D(tex_Ib, x+1, y+1) -\r
+ (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x, y-1) + 3 * tex2D(tex_Ib, x+1, y-1));\r
}\r
}\r
\r
for (int j = 0; j < c_winSize_x; ++j)\r
{\r
int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];\r
- int J = tex2D(tex_J, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);\r
+ int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);\r
\r
int diff = (J - I) * 32;\r
\r
for (int j = 0; j < c_winSize_x; ++j)\r
{\r
int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];\r
- int J = tex2D(tex_J, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);\r
+ int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);\r
\r
errval += ::abs(J - I);\r
}\r
dim3 block(16, 16);\r
dim3 grid(divUp(I.cols, block.x), divUp(I.rows, block.y));\r
\r
- bindTexture(&tex_I, I);\r
- bindTexture(&tex_J, J);\r
+ bindTexture(&tex_Ib, I);\r
+ bindTexture(&tex_Jf, J);\r
\r
int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);\r
const int patchWidth = block.x + 2 * halfWin.x;\r
{\r
namespace pyrlk\r
{\r
- void loadConstants(int cn, float minEigThreshold, int2 winSize, int iters);\r
+ void loadConstants(int2 winSize, int iters);\r
\r
- void calcSharrDeriv_gpu(DevMem2Db src, DevMem2D_<short> dx_buf, DevMem2D_<short> dy_buf, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy, int cn,\r
- cudaStream_t stream = 0);\r
-\r
- void lkSparse_gpu(DevMem2Db I, DevMem2Db J, DevMem2D_<short> dIdx, DevMem2D_<short> dIdy,\r
- const float2* prevPts, float2* nextPts, uchar* status, float* err, bool GET_MIN_EIGENVALS, int ptcount,\r
+ void lkSparse1_gpu(DevMem2Df I, DevMem2Df J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
+ int level, dim3 block, dim3 patch, cudaStream_t stream = 0);\r
+ void lkSparse4_gpu(DevMem2D_<float4> I, DevMem2D_<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,\r
int level, dim3 block, dim3 patch, cudaStream_t stream = 0);\r
\r
void lkDense_gpu(DevMem2Db I, DevMem2Df J, DevMem2Df u, DevMem2Df v, DevMem2Df prevU, DevMem2Df prevV,\r
}\r
}}}\r
\r
-void cv::gpu::PyrLKOpticalFlow::calcSharrDeriv(const GpuMat& src, GpuMat& dIdx, GpuMat& dIdy)\r
-{\r
- using namespace cv::gpu::device::pyrlk;\r
-\r
- CV_Assert(src.rows > 1 && src.cols > 1);\r
- CV_Assert(src.depth() == CV_8U);\r
-\r
- const int cn = src.channels();\r
-\r
- ensureSizeIsEnough(src.size(), CV_MAKETYPE(CV_16S, cn), dx_calcBuf_);\r
- ensureSizeIsEnough(src.size(), CV_MAKETYPE(CV_16S, cn), dy_calcBuf_);\r
-\r
- calcSharrDeriv_gpu(src, dx_calcBuf_, dy_calcBuf_, dIdx, dIdy, cn);\r
-}\r
-\r
-void cv::gpu::PyrLKOpticalFlow::buildImagePyramid(const GpuMat& img0, vector<GpuMat>& pyr, bool withBorder)\r
-{\r
- pyr.resize(maxLevel + 1);\r
-\r
- Size sz = img0.size();\r
-\r
- for (int level = 0; level <= maxLevel; ++level)\r
- {\r
- GpuMat temp;\r
-\r
- if (withBorder)\r
- {\r
- temp.create(sz.height + winSize.height * 2, sz.width + winSize.width * 2, img0.type());\r
- pyr[level] = temp(Rect(winSize.width, winSize.height, sz.width, sz.height));\r
- }\r
- else\r
- {\r
- ensureSizeIsEnough(sz, img0.type(), pyr[level]);\r
- }\r
-\r
- if (level == 0)\r
- img0.copyTo(pyr[level]);\r
- else\r
- pyrDown(pyr[level - 1], pyr[level]);\r
-\r
- if (withBorder)\r
- copyMakeBorder(pyr[level], temp, winSize.height, winSize.height, winSize.width, winSize.width, BORDER_REFLECT_101);\r
-\r
- sz = Size((sz.width + 1) / 2, (sz.height + 1) / 2);\r
-\r
- if (sz.width <= winSize.width || sz.height <= winSize.height)\r
- {\r
- maxLevel = level;\r
- break;\r
- }\r
- }\r
-}\r
-\r
namespace\r
{\r
- void calcPatchSize(cv::Size winSize, int cn, dim3& block, dim3& patch, bool isDeviceArch11)\r
+ void calcPatchSize(cv::Size winSize, dim3& block, dim3& patch, bool isDeviceArch11)\r
{\r
- winSize.width *= cn;\r
-\r
if (winSize.width > 32 && winSize.width > 2 * winSize.height)\r
{\r
block.x = isDeviceArch11 ? 16 : 32;\r
return;\r
}\r
\r
- const int cn = prevImg.channels();\r
-\r
dim3 block, patch;\r
- calcPatchSize(winSize, cn, block, patch, isDeviceArch11_);\r
+ calcPatchSize(winSize, block, patch, isDeviceArch11_);\r
\r
- CV_Assert(maxLevel >= 0 && winSize.width > 2 && winSize.height > 2);\r
+ CV_Assert(prevImg.type() == CV_8UC1 || prevImg.type() == CV_8UC3 || prevImg.type() == CV_8UC4);\r
CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());\r
+ CV_Assert(maxLevel >= 0);\r
+ CV_Assert(winSize.width > 2 && winSize.height > 2);\r
CV_Assert(patch.x > 0 && patch.x < 6 && patch.y > 0 && patch.y < 6);\r
CV_Assert(prevPts.rows == 1 && prevPts.type() == CV_32FC2);\r
\r
ensureSizeIsEnough(1, prevPts.cols, CV_32FC1, *err);\r
\r
// build the image pyramids.\r
- // we pad each level with +/-winSize.{width|height}\r
- // pixels to simplify the further patch extraction.\r
\r
- buildImagePyramid(prevImg, prevPyr_, true);\r
- buildImagePyramid(nextImg, nextPyr_, true);\r
+ prevPyr_.resize(maxLevel + 1);\r
+ nextPyr_.resize(maxLevel + 1);\r
\r
- // dI/dx ~ Ix, dI/dy ~ Iy\r
+ int cn = prevImg.channels();\r
\r
- ensureSizeIsEnough(prevImg.rows + winSize.height * 2, prevImg.cols + winSize.width * 2, CV_MAKETYPE(CV_16S, cn), dx_buf_);\r
- ensureSizeIsEnough(prevImg.rows + winSize.height * 2, prevImg.cols + winSize.width * 2, CV_MAKETYPE(CV_16S, cn), dy_buf_);\r
+ if (cn == 1 || cn == 4)\r
+ {\r
+ prevImg.convertTo(prevPyr_[0], CV_32F);\r
+ nextImg.convertTo(nextPyr_[0], CV_32F);\r
+ }\r
+ else\r
+ {\r
+ cvtColor(prevImg, dx_calcBuf_, COLOR_BGR2BGRA);\r
+ dx_calcBuf_.convertTo(prevPyr_[0], CV_32F);\r
\r
- loadConstants(cn, minEigThreshold, make_int2(winSize.width, winSize.height), iters);\r
+ cvtColor(nextImg, dx_calcBuf_, COLOR_BGR2BGRA);\r
+ dx_calcBuf_.convertTo(nextPyr_[0], CV_32F);\r
+ }\r
\r
- for (int level = maxLevel; level >= 0; level--)\r
+ for (int level = 1; level <= maxLevel; ++level)\r
{\r
- Size imgSize = prevPyr_[level].size();\r
-\r
- GpuMat dxWhole(imgSize.height + winSize.height * 2, imgSize.width + winSize.width * 2, dx_buf_.type(), dx_buf_.data, dx_buf_.step);\r
- GpuMat dyWhole(imgSize.height + winSize.height * 2, imgSize.width + winSize.width * 2, dy_buf_.type(), dy_buf_.data, dy_buf_.step);\r
- dxWhole.setTo(Scalar::all(0));\r
- dyWhole.setTo(Scalar::all(0));\r
- GpuMat dIdx = dxWhole(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));\r
- GpuMat dIdy = dyWhole(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));\r
+ pyrDown(prevPyr_[level - 1], prevPyr_[level]);\r
+ pyrDown(nextPyr_[level - 1], nextPyr_[level]);\r
+ }\r
\r
- calcSharrDeriv(prevPyr_[level], dIdx, dIdy);\r
+ loadConstants(make_int2(winSize.width, winSize.height), iters);\r
\r
- lkSparse_gpu(prevPyr_[level], nextPyr_[level], dIdx, dIdy,\r
- prevPts.ptr<float2>(), nextPts.ptr<float2>(), status.ptr(), level == 0 && err ? err->ptr<float>() : 0, getMinEigenVals, prevPts.cols,\r
- level, block, patch);\r
+ for (int level = maxLevel; level >= 0; level--)\r
+ {\r
+ if (cn == 1)\r
+ {\r
+ lkSparse1_gpu(prevPyr_[level], nextPyr_[level],\r
+ prevPts.ptr<float2>(), nextPts.ptr<float2>(), status.ptr(), level == 0 && err ? err->ptr<float>() : 0, prevPts.cols,\r
+ level, block, patch);\r
+ }\r
+ else\r
+ {\r
+ lkSparse4_gpu(prevPyr_[level], nextPyr_[level],\r
+ prevPts.ptr<float2>(), nextPts.ptr<float2>(), status.ptr(), level == 0 && err ? err->ptr<float>() : 0, prevPts.cols,\r
+ level, block, patch);\r
+ }\r
}\r
}\r
\r
\r
// build the image pyramids.\r
\r
- buildImagePyramid(prevImg, prevPyr_, false);\r
-\r
+ prevPyr_.resize(maxLevel + 1);\r
nextPyr_.resize(maxLevel + 1);\r
+\r
+ prevPyr_[0] = prevImg;\r
nextImg.convertTo(nextPyr_[0], CV_32F);\r
+\r
for (int level = 1; level <= maxLevel; ++level)\r
+ {\r
+ pyrDown(prevPyr_[level - 1], prevPyr_[level]);\r
pyrDown(nextPyr_[level - 1], nextPyr_[level]);\r
+ }\r
\r
uPyr_.resize(2);\r
vPyr_.resize(2);\r
vPyr_[1].setTo(Scalar::all(0));\r
\r
int2 winSize2i = make_int2(winSize.width, winSize.height);\r
- loadConstants(1, minEigThreshold, winSize2i, iters);\r
+ loadConstants(winSize2i, iters);\r
\r
DevMem2Df derr = err ? *err : DevMem2Df();\r
\r
projects / profile / ivi / opencv.git / commitdiff