generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

added support to build without cuda.

Browse Source
This commit is contained in:
Anatoly Baksheev 2010-07-15 13:36:00 +00:00
parent e1bd5aeadd
commit 2c84a66ec7
9 changed files with 169 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CMakeLists.txt
View File

@ -282,6 +282,7 @@ endif()
set(WITH_TBB OFF CACHE BOOL "Include TBB support")
set(WITH_EIGEN2 ON CACHE BOOL "Include Eigen2 support")
set(WITH_CUDA OFF CACHE BOOL "Include NVidia Cuda Runtime support")
# ===================================================
# Macros that checks if module have been installed.
@ -608,6 +609,15 @@ if (WITH_TBB)
endif()
endif()
############################### TBB ################################
if (WITH_CUDA)
find_package(CUDA)
if (CUDA_FOUND)
message(STATUS "CUDA detected.")
set(HAVE_CUDA 1)
endif()
endif()
############################## Eigen2 ##############################
@ -1249,6 +1259,12 @@ else()
message(STATUS " Use TBB: NO")
endif()
if (HAVE_CUDA)
message(STATUS " Uue Cuda: YES")
else()
message(STATUS " Use Cuda: No")
endif()
if(HAVE_EIGEN2)
message(STATUS " Use Eigen2: YES")
else()

3
cvconfig.h.cmake
View File

@ -165,3 +165,6 @@
/* Qt bindings use OpenGL */
#cmakedefine HAVE_HAVE_QT_OPENGL
/* NVidia Cuda Runtime API*/
#cmakedefine HAVE_CUDA

4
modules/core/include/opencv2/core/types_c.h
View File

@ -229,7 +229,9 @@ enum {
CV_StsParseError= -212, /* invalid syntax/structure of the parsed file */
CV_StsNotImplemented= -213, /* the requested function/feature is not implemented */
CV_StsBadMemBlock= -214, /* an allocated block has been corrupted */
CV_StsAssert= -215 /* assertion failed */
CV_StsAssert= -215, /* assertion failed */
CV_GpuNotFound= -216,
CV_GpuApiCallError= -217
};
/****************************************************************************************\

84
modules/gpu/CMakeLists.txt
View File

@ -1,60 +1,52 @@
include(FindCUDA)
if (CUDA_FOUND)
include_directories(${CUDA_INCLUDE_DIRS})
link_directories(${CUDA_LIBRARIES})
#message ("CUDA_LIBRARIES = ${CUDA_LIBRARIES}")
#message ("CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
#message ("CUDA_TARGET_LINK = ${CUDA_TARGET_LINK}")
set(name "gpu")
set(DEPS "opencv_core")
#CUDA_GENERATED_OUTPUT_DIR (Default CMAKE_CURRENT_BINARY_DIR)
set(the_target "opencv_${name}")
#====================================================================================
project(${the_target})
set(name "gpu")
set(DEPS "opencv_core")
add_definitions(-DCVAPI_EXPORTS)
project(opencv_${name})
add_definitions(-DCVAPI_EXPORTS)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/cuda"
"${CMAKE_CURRENT_SOURCE_DIR}/src"
"${CMAKE_CURRENT_BINARY_DIR}")
foreach(d ${DEPS})
foreach(d ${DEPS})
if(${d} MATCHES "opencv_")
string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
include_directories("${d_dir}/include")
endif()
endforeach()
endforeach()
file(GLOB lib_srcs "src/*.cpp")
file(GLOB lib_int_hdrs "src/*.h*")
file(GLOB lib_cuda "cuda/*.cu")
file(GLOB lib_cuda_hdrs "cuda/*.h*")
source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs})
file(GLOB lib_srcs "src/*.cpp")
file(GLOB lib_int_hdrs "src/*.h*")
file(GLOB lib_cuda "cuda/*.cu")
file(GLOB lib_cuda_hdrs "cuda/*.h*")
source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs})
file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")
source_group("Include" FILES ${lib_hdrs})
file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")
source_group("Include" FILES ${lib_hdrs})
if (HAVE_CUDA)
include_directories(${CUDA_INCLUDE_DIRS})
link_directories(${CUDA_LIBRARIES})
if (UNIX OR APPLE)
set (CUDA_NVCC_FLAGS "-Xcompiler;-fPIC")
endif()
CUDA_COMPILE(cuda_objs ${lib_cuda})
#message ("lib cuda : ${cuda_objs}")
#CUDA_BUILD_CLEAN_TARGET()
endif()
set(the_target "opencv_${name}")
#message ("cuda_add_library : ${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs}")
add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${cuda_objs})
if(PCHSupport_FOUND)
add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${cuda_objs})
if(PCHSupport_FOUND)
set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
if(${CMAKE_GENERATOR} MATCHES "Visual*")
@ -64,28 +56,27 @@ if (CUDA_FOUND)
elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
add_precompiled_header(${the_target} ${pch_header})
endif()
endif()
endif()
# For dynamic link numbering convenions
set_target_properties(${the_target} PROPERTIES
# For dynamic link numbering convenions
set_target_properties(${the_target} PROPERTIES
VERSION ${OPENCV_VERSION}
SOVERSION ${OPENCV_SOVERSION}
OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}"
)
# Additional target properties
set_target_properties(${the_target} PROPERTIES
# Additional target properties
set_target_properties(${the_target} PROPERTIES
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
)
# Add the required libraries for linking:
#message (" ++++ target_link_libraries = ${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES}")
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES})
# Add the required libraries for linking:
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES})
if(MSVC)
if(MSVC)
if(CMAKE_CROSSCOMPILING)
set_target_properties(${the_target} PROPERTIES
LINK_FLAGS "/NODEFAULTLIB:secchk"
@ -94,19 +85,18 @@ if (CUDA_FOUND)
set_target_properties(${the_target} PROPERTIES
LINK_FLAGS "/NODEFAULTLIB:libc"
)
endif()
endif()
# Dependencies of this target:
add_dependencies(${the_target} ${DEPS})
# Dependencies of this target:
add_dependencies(${the_target} ${DEPS})
install(TARGETS ${the_target}
install(TARGETS ${the_target}
RUNTIME DESTINATION bin COMPONENT main
LIBRARY DESTINATION lib COMPONENT main
ARCHIVE DESTINATION lib COMPONENT main)
install(FILES ${lib_hdrs}
install(FILES ${lib_hdrs}
DESTINATION include/opencv2/${name}
COMPONENT main)
endif()

11
modules/gpu/include/opencv2/gpu/gpu.hpp
View File

@ -216,6 +216,9 @@ namespace cv
class CudaStream
{
public:
static CudaStream empty();
CudaStream();
~CudaStream();
@ -236,9 +239,13 @@ namespace cv
// converts matrix type, ex from float to uchar depending on type
void enqueueConvert(const GpuMat& src, GpuMat& dst, int type);
//CUstream_st& getStream();
struct Impl;
const Impl& getImpl() const;
private:
void *impl;
Impl *impl;
CudaStream(const CudaStream&);
CudaStream& operator=(const CudaStream&);

22
modules/gpu/src/cudastream.cpp
View File

@ -41,33 +41,37 @@
//M*/
#include "precomp.hpp"
#include "opencv2/gpu/stream_access.hpp"
using namespace cv;
using namespace cv::gpu;
cv::gpu::CudaStream::CudaStream() : impl( fastMalloc(sizeof(cudaStream_t)) )
cv::gpu::CudaStream::CudaStream() : impl( (Impl*)fastMalloc(sizeof(Impl)) )
{
cudaSafeCall( cudaStreamCreate((cudaStream_t*)impl) );
//cudaSafeCall( cudaStreamCreate( &impl->stream) );
}
cv::gpu::CudaStream::~CudaStream()
{
if (impl)
{
cudaSafeCall( cudaStreamDestroy( *(cudaStream_t*)impl ) );
cv::fastFree( impl );
}
}
bool cv::gpu::CudaStream::queryIfComplete()
{
cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );
//cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );
if (err == cudaSuccess)
return true;
//if (err == cudaSuccess)
// return true;
if (err == cudaErrorNotReady)
return false;
//if (err == cudaErrorNotReady)
// return false;
//cudaErrorInvalidResourceHandle
cudaSafeCall( err );
////cudaErrorInvalidResourceHandle
//cudaSafeCall( err );
return true;
}
void cv::gpu::CudaStream::waitForCompletion()

12
modules/gpu/src/initialization.cpp
View File

@ -45,6 +45,16 @@
using namespace cv;
using namespace cv::gpu;
#ifndef HAVE_CUDA
CV_EXPORTS int cv::gpu::getCudaEnabledDeviceCount() { return 0; }
CV_EXPORTS string cv::gpu::getDeviceName(int /*device*/) { cudaSafeCall(0); return 0; }
CV_EXPORTS void cv::gpu::setDevice(int /*device*/) { cudaSafeCall(0); }
CV_EXPORTS void cv::gpu::getComputeCapability(int /*device*/, int* /*major*/, int* /*minor*/) { cudaSafeCall(0); }
CV_EXPORTS int cv::gpu::getNumberOfSMs(int /*device*/) { cudaSafeCall(0); return 0; }
#else
CV_EXPORTS int cv::gpu::getCudaEnabledDeviceCount()
{
int count;
@ -79,3 +89,5 @@ CV_EXPORTS int cv::gpu::getNumberOfSMs(int device)
cudaSafeCall( cudaGetDeviceProperties( &prop, device ) );
return prop.multiProcessorCount;
}
#endif

38
modules/gpu/src/precomp.hpp
View File

@ -57,41 +57,39 @@
#include "cuda_shared.hpp"
#ifndef HAVE_CUDA
#define cudaSafeCall(err) CV_Error(CV_GpuNotFound, "The library is compilled with no GPU support")
#define cudaCallerSafeCall(err) CV_Error(CV_GpuNotFound, "The library is compilled with no GPU support")
#else /* HAVE_CUDA */
#if _MSC_VER >= 1200
#pragma warning (disable : 4100 4211 4201 4408)
#pragma warning (disable : 4100 4211 4201 4408)
#endif
#include "cuda_runtime_api.h"
#define cudaCallerSafeCall(err) err;
#define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__)
//inline void __cudaSafeCall( cudaError err, const char *file, const int line )
//{
// if( cudaSuccess != err)
// CV_Error_(CV_StsAssert, ("%s(%i) : Runtime API error : %s.\n", cudaGetErrorString(err)));
//}
#ifdef __GNUC__
#define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__, __func__)
#else
#define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__)
#endif
namespace cv
{
namespace gpu
{
inline void __cudaSafeCall( cudaError err, const char *file, const int line )
static inline void __cudaSafeCall( cudaError err, const char *file, const int line, const char *func = "")
{
if( cudaSuccess != err)
{
std::cerr << file << "(" << line << ") : cudaSafeCall() Runtime API error : " << cudaGetErrorString(err) << "\n";
exit(-1);
}
}
template<class T>
inline DevMem2D_<T> getDevMem(const GpuMat& mat)
{
return DevMem2D_<T>(mat.rows, mat.cols, mat.data, mat.step);
cv::error( cv::Exception(CV_GpuApiCallError, cudaGetErrorString(err), func, file, line) );
}
}
}
#endif /* HAVE_CUDA */
#endif

3
modules/gpu/src/stereobm_gpu.cpp
View File

@ -41,7 +41,6 @@
//M*/
#include "precomp.hpp"
#include <limits>
using namespace cv;
using namespace cv::gpu;
@ -69,5 +68,5 @@ void StereoBM_GPU::operator() ( const GpuMat& left, const GpuMat& right, GpuMat&
DevMem2D disp = disparity;
DevMem2D_<uint> mssd = minSSD;
impl::stereoBM_GPU(left, right, disp, ndisp, mssd);
cudaCallerSafeCall( impl::stereoBM_GPU(left, right, disp, ndisp, mssd) );
}