diff --git a/CMakeLists.txt b/CMakeLists.txt index 2d30d92b8d..a752b2d378 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,7 +42,6 @@ cmake_minimum_required(VERSION 2.4) if(MSVC) set(CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE) - set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} /MP) endif() #set(CMAKE_C_COMPILER "/opt/BullseyeCoverage/bin/gcc") diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt index 9529e4dda7..645f4e860a 100644 --- a/modules/gpu/CMakeLists.txt +++ b/modules/gpu/CMakeLists.txt @@ -75,7 +75,7 @@ if (HAVE_CUDA) #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") #string(REPLACE "/W4" "/W3" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") - #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4211 /wd4201 /wd4100 /wd4505 /wd4408") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4211 /wd4201 /wd4100 /wd4505 /wd4408") string(REPLACE "/EHsc-" "/EHs" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") string(REPLACE "/EHsc-" "/EHs" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp index 72d66fc786..bf9abbaa07 100644 --- a/modules/gpu/include/opencv2/gpu/gpu.hpp +++ b/modules/gpu/include/opencv2/gpu/gpu.hpp @@ -235,7 +235,7 @@ namespace cv class CV_EXPORTS CudaMem { - public: + public: enum { ALLOC_PAGE_LOCKED = 1, ALLOC_ZEROCOPY = 2, ALLOC_WRITE_COMBINED = 4 }; CudaMem(); @@ -266,6 +266,8 @@ namespace cv Mat createMatHeader() const; operator Mat() const; + //! maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware. + GpuMat createGpuMatHeader() const; operator GpuMat() const; //returns if host memory can be mapperd to gpu address space; @@ -295,7 +297,6 @@ namespace cv uchar* dataend; int alloc_type; - }; //////////////////////////////// CudaStream //////////////////////////////// @@ -341,10 +342,11 @@ namespace cv }; ////////////////////////////// Image processing ////////////////////////////// - + // DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation. + // xymap.type() == xymap.type() == CV_32FC1 CV_EXPORTS void remap(const GpuMat& src, const GpuMat& xmap, const GpuMat& ymap, GpuMat& dst); - + // Does mean shift filtering on GPU. CV_EXPORTS void meanShiftFiltering_GPU(const GpuMat& src, GpuMat& dst, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)); //////////////////////////////// StereoBM_GPU //////////////////////////////// @@ -358,8 +360,7 @@ namespace cv //! the default constructor StereoBM_GPU(); - //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size - //! ndisparities should be multiple of 8. SSD WindowsSize is fixed to 19 now + //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8. StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ); //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair @@ -374,10 +375,9 @@ namespace cv // It queries current active device. static bool checkIfGpuCallReasonable(); - int preset; int ndisp; int winSize; - + int preset; // If avergeTexThreshold == 0 => post procesing is disabled // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image @@ -389,7 +389,8 @@ namespace cv }; ////////////////////////// StereoBeliefPropagation /////////////////////////// - + // "Efficient Belief Propagation for Early Vision" + // P.Felzenszwalb class CV_EXPORTS StereoBeliefPropagation { public: @@ -418,7 +419,7 @@ namespace cv //! Acync version void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream); - + //! version for user specified data term void operator()(const GpuMat& data, GpuMat& disparity); void operator()(const GpuMat& data, GpuMat& disparity, Stream& stream); @@ -441,6 +442,9 @@ namespace cv }; /////////////////////////// StereoConstantSpaceBP /////////////////////////// + // "A Constant-Space Belief Propagation Algorithm for Stereo Matching" + // Qingxiong Yang, Liang Wang†, Narendra Ahuja + // http://vision.ai.uiuc.edu/~qyang6/ class CV_EXPORTS StereoConstantSpaceBP { diff --git a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp b/modules/gpu/include/opencv2/gpu/matrix_operations.hpp index 8e7cf951ff..424c234948 100644 --- a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp +++ b/modules/gpu/include/opencv2/gpu/matrix_operations.hpp @@ -411,6 +411,9 @@ inline void CudaMem::create(Size _size, int _type, int _alloc_type) { create(_si inline Mat CudaMem::createMatHeader() const { return Mat(size(), type(), data); } inline CudaMem::operator Mat() const { return createMatHeader(); } +inline CudaMem::operator GpuMat() const { return createGpuMatHeader(); } +//CPP GpuMat CudaMem::createGpuMatHeader() const; + inline bool CudaMem::isContinuous() const { return (flags & Mat::CONTINUOUS_FLAG) != 0; } inline size_t CudaMem::elemSize() const { return CV_ELEM_SIZE(flags); } inline size_t CudaMem::elemSize1() const { return CV_ELEM_SIZE1(flags); } diff --git a/modules/gpu/src/constantspacebp_gpu.cpp b/modules/gpu/src/constantspacebp_gpu.cpp index 39d13e3080..cf854adab3 100644 --- a/modules/gpu/src/constantspacebp_gpu.cpp +++ b/modules/gpu/src/constantspacebp_gpu.cpp @@ -130,8 +130,7 @@ cv::gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp_, int iters_, in template static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2], GpuMat l[2], GpuMat r[2], GpuMat disp_selected_pyr[2], GpuMat& data_cost, GpuMat& data_cost_selected, - GpuMat& temp, GpuMat& out, const GpuMat& left, const GpuMat& right, GpuMat& disp, - bool use_local_init_data_cost, cudaStream_t stream) + GpuMat& temp, GpuMat& out, const GpuMat& left, const GpuMat& right, GpuMat& disp, cudaStream_t stream) { CV_DbgAssert(0 < rthis.ndisp && 0 < rthis.iters && 0 < rthis.levels && 0 < rthis.nr_plane && left.rows == right.rows && left.cols == right.cols && left.type() == right.type()); @@ -225,7 +224,7 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2] if (i == levels - 1) { csbp::init_data_cost(left.rows, left.cols, disp_selected_pyr[cur_idx].ptr(), data_cost_selected.ptr(), - step_pyr[i], rows_pyr[i], cols_pyr[i], i, nr_plane_pyr[i], rthis.ndisp, left.channels(), use_local_init_data_cost, stream); + step_pyr[i], rows_pyr[i], cols_pyr[i], i, nr_plane_pyr[i], rthis.ndisp, left.channels(), rthis.use_local_init_data_cost, stream); } else { @@ -264,21 +263,20 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2] typedef void (*csbp_operator_t)(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2], GpuMat l[2], GpuMat r[2], GpuMat disp_selected_pyr[2], GpuMat& data_cost, GpuMat& data_cost_selected, - GpuMat& temp, GpuMat& out, const GpuMat& left, const GpuMat& right, GpuMat& disp, - bool use_local_init_data_cost, cudaStream_t stream); + GpuMat& temp, GpuMat& out, const GpuMat& left, const GpuMat& right, GpuMat& disp, cudaStream_t stream); const static csbp_operator_t operators[] = {0, 0, 0, csbp_operator, 0, csbp_operator, 0, 0}; void cv::gpu::StereoConstantSpaceBP::operator()(const GpuMat& left, const GpuMat& right, GpuMat& disp) { CV_Assert(msg_type == CV_32F || msg_type == CV_16S); - operators[msg_type](*this, u, d, l, r, disp_selected_pyr, data_cost, data_cost_selected, temp, out, left, right, disp, use_local_init_data_cost, 0); + operators[msg_type](*this, u, d, l, r, disp_selected_pyr, data_cost, data_cost_selected, temp, out, left, right, disp, 0); } void cv::gpu::StereoConstantSpaceBP::operator()(const GpuMat& left, const GpuMat& right, GpuMat& disp, Stream& stream) { CV_Assert(msg_type == CV_32F || msg_type == CV_16S); - operators[msg_type](*this, u, d, l, r, disp_selected_pyr, data_cost, data_cost_selected, temp, out, left, right, disp, use_local_init_data_cost, StreamAccessor::getStream(stream)); + operators[msg_type](*this, u, d, l, r, disp_selected_pyr, data_cost, data_cost_selected, temp, out, left, right, disp, StreamAccessor::getStream(stream)); } #endif /* !defined (HAVE_CUDA) */ diff --git a/modules/gpu/src/imgproc_gpu.cpp b/modules/gpu/src/imgproc_gpu.cpp index 2166ad012d..861b03a454 100644 --- a/modules/gpu/src/imgproc_gpu.cpp +++ b/modules/gpu/src/imgproc_gpu.cpp @@ -94,7 +94,7 @@ void cv::gpu::meanShiftFiltering_GPU(const GpuMat& src, GpuMat& dst, int sp, int if( !(criteria.type & TermCriteria::EPS) ) eps = 1.f; - eps = std::max(criteria.epsilon, 0.0); + eps = (float)std::max(criteria.epsilon, 0.0); impl::meanShiftFiltering_gpu(src, dst, sp, sr, maxIter, eps); } diff --git a/modules/gpu/src/matrix_operations.cpp b/modules/gpu/src/matrix_operations.cpp index 518426c357..b075d809dc 100644 --- a/modules/gpu/src/matrix_operations.cpp +++ b/modules/gpu/src/matrix_operations.cpp @@ -70,6 +70,7 @@ namespace cv void CudaMem::create(int /*_rows*/, int /*_cols*/, int /*_type*/, int /*type_alloc*/) { throw_nogpu(); } bool CudaMem::can_device_map_to_host() { throw_nogpu(); return false; } void CudaMem::release() { throw_nogpu(); } + GpuMat CudaMem::createGpuMatHeader () const { throw_nogpu(); return GpuMat(); } } } @@ -310,7 +311,7 @@ void cv::gpu::CudaMem::create(int _rows, int _cols, int _type, int _alloc_type) } } -inline CudaMem::operator GpuMat() const +GpuMat cv::gpu::CudaMem::createGpuMatHeader () const { GpuMat res; if (alloc_type == ALLOC_ZEROCOPY)