cmake_minimum_required(VERSION 2.8)
project(PyHST)

set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
set(CMAKE_VERBOSE_MAKEFILE YES)

set(DISABLE_GPU FALSE CACHE BOOL "Disable GPU acceleration")
set(DISABLE_CUDA FALSE CACHE BOOL "Disable CUDA support")
set(DISABLE_DFI FALSE CACHE BOOL "Disable DFI support")
set(DISABLE_OPENCL TRUE CACHE BOOL "Disable OpenCL support")
set(DISABLE_SIMD TRUE CACHE BOOL "Disable SIMD instructions")
set(DISABLE_HWCHECK FALSE CACHE BOOL "Disable GPU detection")
set(FALLBACK_CPU TRUE CACHE BOOL "Fallback to CPU reconstruction if GPUs are not found")
set(DISABLE_MKL FALSE CACHE BOOL "Disable Intel Kernel Library support")
set(DISABLE_FFTW3 FALSE CACHE BOOL "Disable FFTW3 library support")
set(DISABLE_THREADS FALSE CACHE BOOL "Disable multi-threading and, hence, support of multiple GPU cores")
set(DISABLE_PARALLEL_IO FALSE CACHE BOOL "Disable parallel i/o")
set(DISABLE_HYBRID TRUE CACHE BOOL "Enable hybrid GPU/CPU reconstruction mode")
set(MEASURE_TIMINGS TRUE CACHE BOOL "Report execution times")
set(IO_BENCHMARK FALSE CACHE BOOL "Benchmark I/O, no reconstruction")
set(RECON_BENCHMARK FALSE CACHE BOOL "Benchmark reconstruction, limited I/O")
set(BP_BENCHMARK FALSE CACHE BOOL "Benchmark Back Projection, limited PCIe transfers & I/O")
set(DISABLE_VIPS FALSE CACHE BOOL "Disable support of VIPS library")
set(FAST_MODE FALSE CACHE BOOL "Allow performance optimizations at the expenses of precision")
set(IGNORE_OLD_HARDWARE TRUE CACHE BOOL "Optimize for latest GPU family and disable older GPUs")
set(ENABLE_KEPLER_INSTRUCTIONS 0 CACHE STRING "Allow Kepler specific optimizations, over GPUs will fail")
set(MULTISLICE_MODE TRUE CACHE BOOL "Transfer a whole slice to GPU while processing another one")
set(SLICE_BLOCK 1 CACHE STRING "Number of slices per back projection")
set(ASTRA_SCALING TRUE CACHE BOOL "Enbale ASTRA-style sinogram scaling")


set(USE_FASTWRITER 0 CACHE INT "Use fastwriter with the buffer of specified size (MB)")

if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
    set(CMAKE_BUILD_TYPE RELEASE CACHE STRING "" FORCE)
    if (DISABLE_SIMD)
        set(CMAKE_C_FLAGS_RELEASE "-O2" CACHE STRING "" FORCE)
        set(CMAKE_CXX_FLAGS_RELEASE "-O2" CACHE STRING "" FORCE)
    else (DISABLE_SIMD)
        set(CMAKE_C_FLAGS_RELEASE "-O2 -march=native -mfpmath=sse -ftree-vectorize -ffast-math " CACHE STRING "" FORCE)
        set(CMAKE_CXX_FLAGS_RELEASE "-O2 -march=native -mfpmath=sse -ftree-vectorize -ffast-math" CACHE STRING "" FORCE)
    endif (DISABLE_SIMD)
endif ()


include(CheckIncludeFiles)
include(CheckPythonModule)
include(MakePythonArray)

CHECK_INCLUDE_FILES("sys/types.h;unistd.h;sched.h" HAVE_SCHED_HEADERS)

find_program(SED_EXECUTABLE sed)
find_program(LS_EXECUTABLE ls)
find_program(HEAD_EXECUTABLE head)
find_program(FIND_EXECUTABLE find)
find_program(CUT_EXECUTABLE cut)
find_program(XARGS_EXECUTABLE xargs)
find_program(LN_EXECUTABLE ln)
find_program(RM_EXECUTABLE rm)
mark_as_advanced(SED_EXECUTABLE LS_EXECUTABLE HEAD_EXECUTABLE FIND_EXECUTABLE)

set (PROVIDE_CPU_MODE TRUE)
set (CPU_MULTITHREADED TRUE)

if (DISABLE_THREADS)
    set(USE_THREADS FALSE)
    set(MULTISLICE_MODE FALSE)
else ()
    set(USE_THREADS TRUE)
endif ()

if (DISABLE_PARALLEL_IO)
    set(USE_PARALLEL_IO FALSE)
else ()
    set(USE_PARALLEL_IO TRUE)
endif ()

if (BP_BENCHMARK)
    set(RECON_BENCHMARK TRUE)
endif()

if (RECON_BENCHMARK)
    set(IO_BENCHMARK FALSE)
#    set(USE_PARALLEL_IO FALSE)
endif()

if (ENABLE_KEPLER_INSTRUCTIONS GREATER 0)
    set(IGNORE_OLD_HARDWARE TRUE)
endif()


find_package(GLIB2 REQUIRED)

if (NOT GTHREAD2_LIBRARIES)
    set(USE_THREADS FALSE)
endif (NOT GTHREAD2_LIBRARIES)


find_package(PkgConfig REQUIRED)
if (USE_FASTWRITER GREATER 0)
    pkg_check_modules(FASTWRITER fastwriter REQUIRED)
    set(MULTISLICE_MODE TRUE)
endif (USE_FASTWRITER GREATER 0)

find_package(PythonInterp REQUIRED)
find_package(PythonLibs REQUIRED)
CHECK_PYTHON_MODULE(logging PYTHON_HAVE_LOGGING REQUIRED)
CHECK_PYTHON_MODULE(numpy PYTHON_HAVE_NUMERIC REQUIRED)
CHECK_PYTHON_MODULE(PIL PYTHON_HAVE_PIL REQUIRED)

if (NOT DISABLE_VIPS)
    CHECK_PYTHON_MODULE(vipsCC PYTHON_HAVE_VIPS QUIET)
else ()
    set(PYTHON_HAVE_VIPS FALSE)
endif (NOT DISABLE_VIPS)

if (DISABLE_GPU)
    set(DISABLE_CUDA TRUE)
endif (DISABLE_GPU)

if (NOT DISABLE_CUDA OR NOT DISABLE_OPENCL)
#   We are going to detect CUDA for OpenCL as well. We need it to find the libraries

    set (MINIMAL_CUDA_VERSION 2.2)
    find_package(CUDA ${MINIMAL_CUDA_VERSION} QUIET)
    find_package(ATI QUIET)
    find_package(Intel QUIET)

    if (NOT DISABLE_OPENCL)
	find_package(OpenCL QUIET)
	find_package(OCLFFT QUIET)
    endif(NOT DISABLE_OPENCL)
    
    if (DISABLE_CUDA)
	set(CUDA_FOUND)
    endif(DISABLE_CUDA)
endif()

if (NOT DISABLE_MKL)
    find_package(MKL QUIET)
endif()

if (NOT DISABLE_FFTW3)
    find_package(FFTW3 QUIET)
endif()

if (CMAKE_BUILD_TYPE)
    set(CFLAGS CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE})
    set(CPPFLAGS CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE})
else(CMAKE_BUILD_TYPE)
    set(CFLAGS CMAKE_C_FLAGS)
    set(CPPFLAGS CMAKE_CXX_FLAGS)
endif(CMAKE_BUILD_TYPE)


set(PYHST_INCLUDE_DIRS ${GLIB2_INCLUDE_DIR})
set(PYHST_LIBRARY_DIRS )
set(PYHST_LIBRARIES ${GLIB2_LIBRARIES} ${GTHREAD2_LIBRARIES})
set(PYHST_DEFINITIONS)


message("")
message("Configuration")
message("-------------")

if (GLIB2_FOUND)
    if (GTHREAD2_LIBRARIES OR DISABLE_THREADS)
        message(" * GLIB2 is found, good")
    else ()
        message(" * GLIB2 is found, but GTHREAD2 library is not available")
    endif()
endif()

if (PYTHONINTERP_FOUND)
    if (PYTHONLIBS_FOUND)
	set(PYHST_OPTIONAL_PYTHON_MODULES)

	if (PYTHON_HAVE_VIPS)
	    set(PYHST_OPTIONAL_PYTHON_MODULES "${PYHST_OPTIONAL_PYTHON_MODULES} VIPS")
	endif (PYTHON_HAVE_VIPS)

	if (PYHST_OPTIONAL_PYTHON_MODULES)
	    message(" * Python is configured with optional modules:${PYHST_OPTIONAL_PYTHON_MODULES}")
	else ()
	    message(" * Python and mandatory libraries are found")
	endif ()
    else()
        message(" * Python libraries are not found")
    endif()
else()
    message(" * Python is not found")
endif()


if (OPENCL_FOUND)
    if (DISABLE_HWCHECK)
	set(OPENCL_CPU_SUPPORT TRUE)
	set(OPENCL_GPU_SUPPORT TRUE)
    else ()
	if (DISABLE_GPU AND NOT OPENCL_CPU_SUPPORT)
	    message(" * OpenCL is found, but CPU-enabled platform is not detected...")
	    set(OPENCL_FOUND)
	elseif (NOT DISABLE_GPU AND NOT OPENCL_GPU_SUPPORT AND CUDA_FOUND)
	    message(" * OpenCL is found, but supported GPU is not found...")
	    set(OPENCL_FOUND)
	endif()
    endif()
    
    if (OPENCL_FOUND)
	if (OCLFFT_FOUND)
	    set(MSG_OPENCL_STACK "oclfft")
	else ()
	    message(" * OpenCL is found, but suitable FFT library is missing...")
	    set(OPENCL_FOUND)
	endif()
    endif ()
elseif (DISABLE_OPENCL)
    message(" * OpenCL support is disabled, checking other backends...")
else()
    message(" * OpenCL platform is not found, checking other backends...")
endif()

if (FALLBACK_CPU)
    set(MSG_FALLBACK " with fallback")
else()
    set(MSG_FALLBACK "")
endif()

if (OPENCL_FOUND)
    set(CUDA_FOUND)
    
# Issues with pinned memory, to be fixed
#    set(MULTISLICE_MODE FALSE)
    
    foreach (arg ${OPENCL_PLATFORMS})
	set(MSG_OPENCL_PLATFORMS "${MSG_OPENCL_PLATFORMS} ${arg}")
    endforeach()
    
    if (DISABLE_GPU)
	set (OPENCL_GPU_SUPPORT FALSE)
	message(" * OpenCL is found but GPU support is disabled, building OpenCL/CPU flavour${MSG_FALLBACK}")
    elseif (DISABLE_HYBRID)
	message(" * OpenCL is found, building OpenCL/GPU flavour${MSG_FALLBACK}")
    elseif (OPENCL_CPU_SUPPORT)
	message(" * OpenCL is found, Building OpenCL/HYBRID flavour${MSG_FALLBACK}")
    else ()
	message(" * OpenCL is found, Building OpenCL+CPU/HYBRID flavour")
    endif ()
    
    message(" * OpenCL platforms: ${MSG_OPENCL_PLATFORMS}, libraries: ${MSG_OPENCL_STACK}")
elseif (CUDA_FOUND)
    if (CUDA_CUT_INCLUDE_DIR AND (CUDA_VERSION_MAJOR GREATER 4 OR  CUDA_CUT_LIBRARY) AND (CUDA_VERSION_MAJOR LESS 4 OR CUDA_NPP_LIBRARIES))
	set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DCUDA_VERSION_MAJOR=${CUDA_VERSION_MAJOR} -DCUDA_VERSION_MINOR=${CUDA_VERSION_MINOR})
        if (DISABLE_HYBRID)
            message(" * CUDA ${CUDA_VERSION} and SDK are found, GPU flavour is going to be builded${MSG_FALLBACK}")
        else (DISABLE_HYBRID)
            message(" * CUDA ${CUDA_VERSION} and SDK are found, HYBRID flavour is going to be builded")
        endif (DISABLE_HYBRID)
    elseif (CUDA_CUT_INCLUDE_DIR  AND (CUDA_VERSION_MAJOR GREATER 4 OR CUDA_CUT_LIBRARY))
        message(" * CUDA ${CUDA_VERSION} and SDK are found but NPP library is missing, CPU flavour is going to be builded")
        unset(CUDA_FOUND)
    elseif (CUDA_CUT_INCLUDE_DIR)
        message(" * CUDA ${CUDA_VERSION} is found but SDK is not compiled yet, CPU flavour is going to be builded")
        unset(CUDA_FOUND)
    else ()
        message(" * CUDA ${CUDA_VERSION} is found but SDK is not available, CPU flavour is going to be builded")
        unset(CUDA_FOUND)
    endif()
elseif(DISABLE_GPU)
    message(" * GPU accleration is disabled, CPU flavour is going to be builded")
elseif(DISABLE_CUDA)
    message(" * CUDA support is disabled, CPU flavour is going to be builded")
else()
    if (CUDA_VERSION)
        message(" * CUDA ${CUDA_VERSION} is not supported, CPU flavour is going to be builded")
        message(" * Install at least CUDA and SDK versions ${MINIMAL_CUDA_VERSION} in order to use GPU code")
    else ()
        message(" * CUDA not found, CPU flavour is going to be builded")
    endif()
endif()

if (MKL_FOUND AND MKL_LP_SEQUENTIAL_LIBRARIES AND MKL_FFTW_INCLUDE_DIR)
    if (FFTW3_FOUND)
        message(" * FFTW3 and Intel Math Kernel Library are found, using MKL")
    else ()
        message(" * Intel Math Kernel Library are found")
    endif ()

    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_USE_FFTW)
    set(PYHST_INCLUDE_DIRS ${PYHST_INCLUDE_DIRS} ${MKL_INCLUDE_DIR} ${MKL_FFTW_INCLUDE_DIR})
    set(PYHST_LIBRARIES ${PYHST_LIBRARIES} ${MKL_LP_SEQUENTIAL_LIBRARIES})
elseif (FFTW3_FOUND AND FFTW3_FFTWF_LIBRARY)
    if (DISABLE_MKL)
        message(" * Intel Math Kernel Library is disabled, using FFTW3")
    else ()
        message(" * Intel Math Kernel Library is not found, using FFTW3")
    endif()

    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_USE_FFTW)
    set(PYHST_INCLUDE_DIRS ${PYHST_INCLUDE_DIRS} ${FFTW3_INCLUDE_DIR})
    set(PYHST_LIBRARIES ${PYHST_LIBRARIES} ${FFTW3_FFTWF_LIBRARY})
else ()
    if (DISABLE_MKL AND DISABLE_FFTW3)
        message(" * Intel Math Kernel Library and FFTW3 are disabled, using embedded FFT routine")
    elseif (DISABLE_MKL)
        message(" * MKL is disabled and FFTW3 is not found, using embedded FFT routine")
    elseif (DISABLE_FFTW3)
        message(" * MKL is not found and FFTW3 is disabled, using embedded FFT routine")
    else()
        message(" * Neither Intel Math Kernel Library nor FFTW3 are found, using embedded FFT routine")
    endif()

    if (CUDA_FOUND OR OPENCL_FOUND)
        if (NOT DISABLE_HYBRID AND USE_THREADS)
            message(" * Single CPU thread only, because embedded FFT does not support multi-threading")
	    set (CPU_MULTITHREADED FALSE)
        endif ()
    else()
        message(" * Embedded FFT is working in single-threaded environment only")
        set(USE_THREADS FALSE)
    endif()
endif()

if (USE_THREADS)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHW_USE_THREADS)
    set(CMAKE_THREAD_MESSAGE "multi-thread")
else(USE_THREADS)
    set(USE_PARALLEL_IO FALSE)
    set(CMAKE_THREAD_MESSAGE "single-thread")
endif (USE_THREADS)

if (MEASURE_TIMINGS)
    message(" * Build configuration: ${CMAKE_BUILD_TYPE}, ${CMAKE_THREAD_MESSAGE} with timing information")
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_MEASURE_TIMINGS)
else(MEASURE_TIMINGS)
    message(" * Build configuration: ${CMAKE_BUILD_TYPE}, ${CMAKE_THREAD_MESSAGE}")
endif(MEASURE_TIMINGS)

if (MULTISLICE_MODE)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHST_MULTISLICE_MODE -DSLICE_BLOCK=${SLICE_BLOCK})
else (MULTISLICE_MODE)
    set(SLICE_BLOCK 1)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DSLICE_BLOCK=1)
#    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DSLICE_BLOCK=${SLICE_BLOCK})
endif (MULTISLICE_MODE)

if (FAST_MODE)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHST_FAST_MODE)
    if (MULTISLICE_MODE)
        set(MODE_MSG "Fast multislice${SLICE_BLOCK}")
    else (MULTISLICE_MODE)
        set(MODE_MSG "Fast")
    endif (MULTISLICE_MODE)
else (FAST_MODE)
    if (MULTISLICE_MODE)
        set(MODE_MSG "Multislice${SLICE_BLOCK}")
    else (MULTISLICE_MODE)
        set(MODE_MSG "Standard")
    endif (MULTISLICE_MODE)
endif (FAST_MODE)

if (DISABLE_SIMD) 
    set(MODE_MSG "${MODE_MSG} C/C++")
else (DISABLE_SIMD)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHW_USE_SIMD)
    set(MODE_MSG "${MODE_MSG} C+SIMD")
endif (DISABLE_SIMD)

if (USE_PARALLEL_IO)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHW_USE_PARALLEL_IO)
    set(MODE_MSG "${MODE_MSG}, Parallel I/O")
else (USE_PARALLEL_IO)
    set(MODE_MSG "${MODE_MSG}, Sequential I/O")
endif (USE_PARALLEL_IO)

if (USE_FASTWRITER GREATER 0)
    set(PYHST_INCLUDE_DIRS ${PYHST_INCLUDE_DIRS} ${FASTWRITER_INCLUDE_DIRS})
    set(PYHST_LIBRARIES ${PYHST_LIBRARIES} ${FASTWRITER_LIBRARIES})
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHST_USE_FASTWRITER=${USE_FASTWRITER})
    set(MODE_MSG "${MODE_MSG} with FastWriter")
endif (USE_FASTWRITER GREATER 0)


if (IGNORE_OLD_HARDWARE)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHW_IGNORE_OLD_HARDWARE)
    if (ENABLE_KEPLER_INSTRUCTIONS GREATER 0)
        set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHST_OPTIMIZE_KEPLER=${ENABLE_KEPLER_INSTRUCTIONS})
        if (${ENABLE_KEPLER_INSTRUCTIONS} GREATER 2) 
            set(MODE_MSG "${MODE_MSG}, Kepler Support (SM: ${ENABLE_KEPLER_INSTRUCTIONS}+)")
        else()
            set(MODE_MSG "${MODE_MSG}, Kepler Support")
        endif()
    else ()
        set(MODE_MSG "${MODE_MSG}, Recent Hardware")
    endif ()
else (IGNORE_OLD_HARDWARE)
    set(MODE_MSG "${MODE_MSG}, Legacy Hardware")
endif (IGNORE_OLD_HARDWARE)

message(" * Optimizations: ${MODE_MSG}")

if (CUDA_FOUND)
    if (IGNORE_OLD_HARDWARE)
        if (ENABLE_KEPLER_INSTRUCTIONS)
	    set (SUPPORTED_GPU_MESSAGE "Kepler")
        else (ENABLE_KEPLER_INSTRUCTIONS)
	    set (SUPPORTED_GPU_MESSAGE "Kepler, Fermi")
        endif (ENABLE_KEPLER_INSTRUCTIONS)
    else (IGNORE_OLD_HARDWARE)
	set (SUPPORTED_GPU_MESSAGE "GT200, Fermi, Kepler")
    endif (IGNORE_OLD_HARDWARE)
endif (CUDA_FOUND)

if (NOT DISABLE_SIMD)
	set (SUPPORTED_CPU_MESSAGE "Intel/AMD SSSE3 capable")
endif (NOT DISABLE_SIMD)

if (SUPPORTED_CPU_MESSAGE OR SUPPORTED_GPU_MESSAGE)
    if (SUPPORTED_CPU_MESSAGE AND SUPPORTED_GPU_MESSAGE)
	message(" * Supported Hardware: ${SUPPORTED_CPU_MESSAGE} CPUs and ${SUPPORTED_GPU_MESSAGE} GPUs")
    elseif (SUPPORTED_GPU_MESSAGE)
	message(" * Supported Hardware: ${SUPPORTED_GPU_MESSAGE}")
    elseif (SUPPORTED_CPU_MESSAGE)
	message(" * Supported Hardware: ${SUPPORTED_CPU_MESSAGE} CPUs")
    endif()
endif()


if (CUDA_FOUND)
    if (DISABLE_DFI)
        message(" * Algorithms: FBP")
    else (DISABLE_DFI)
        message(" * Algorithms: FBP, DFI")
        set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_ENABLE_DFI)
    endif (DISABLE_DFI)
else (CUDA_FOUND)
    message(" * Algorithms: FBP")
endif (CUDA_FOUND)


if (IO_BENCHMARK)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_IO_BENCHMARK)
    message(" * I/O Benchmark Mode")
endif (IO_BENCHMARK)

if (RECON_BENCHMARK)
    if (BP_BENCHMARK) 
	set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_RECON_BENCHMARK -DPYHST_BP_BENCHMARK)
	message(" * BackProjection Benchmark Mode")
    else()
	set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_RECON_BENCHMARK)
	message(" * Reconstruction Benchmark Mode")
    endif()
else (RECON_BENCHMARK)
    if (ASTRA_SCALING)
	set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DPYHST_ASTRA_SCALING)
	message(" * Scaling: Astra-style")
    else (ASTRA_SCALING)
	message(" * Scaling: PyHST-style")
    endif (ASTRA_SCALING)
endif (RECON_BENCHMARK)

if (HAVE_SCHED_HEADERS)
    set(PYHST_DEFINITIONS ${PYHST_DEFINITIONS} -DHW_HAVE_SCHED_HEADERS)
endif (HAVE_SCHED_HEADERS)

message(" * CFLAGS: ${${CFLAGS}}")
message(" * CPPFLAGS: ${${CPPFLAGS}}")
message("\n")

#if (MEASURE_TIMINGS)
#    set(${CFLAGS} "${${CFLAGS}} -DPYHST_MEASURE_TIMINGS")
#    set(${CPPFLAGS} "${${CPPFLAGS}} -DPYHST_MEASURE_TIMINGS")
#endif()

MAKE_PYTHON_ARRAY(setUPPY_INCLUDES ${PYHST_INCLUDE_DIRS})
MAKE_PYTHON_ARRAY(setUPPY_LIBRARY_DIRS ${PYHST_LIBRARY_DIRS}) 
MAKE_PYTHON_ARRAY(setUPPY_LIBS ${PYHST_LIBRARIES})
MAKE_PYTHON_ARRAY(setUPPY_DEFINES ${PYHST_DEFINITIONS})

FILE(WRITE ${CMAKE_SOURCE_DIR}/build_config.py
    CFLAGS="${${CFLAGS}}"\n
    INCLUDES=${setUPPY_INCLUDES}\n
    DEFINES=${setUPPY_DEFINES}\n
    LIBDIRS=${setUPPY_LIBRARY_DIRS}\n
    LIBS=${setUPPY_LIBS}\n
    )

if (NOT PYTHON_HAVE_VIPS)
    FILE(APPEND ${CMAKE_SOURCE_DIR}/build_config.py
	DISABLE_VIPS=True
    )
endif()

#It's a bug fix
set(DISTCLEANED_SLASH \\)
set(DISTCLEANED_SEMICOLON \;)

if (FALLBACK_CPU)
    set(HW_USE_CPU ",HW_USE_CPU=0")
else()
    set(HW_USE_CPU "")
endif()

if(OPENCL_FOUND)
    ADD_SUBDIRECTORY(hst_opencl)

    if (OPENCL_GPU_SUPPORT)
	ADD_CUSTOM_TARGET(gpu ALL)
	ADD_DEPENDENCIES(gpu hst_opencl)

	if (FALLBACK_CPU)
	    ADD_DEPENDENCIES(gpu hst_cpu)
	endif (FALLBACK_CPU)

	if (DISABLE_HYBRID)
    	    ADD_CUSTOM_COMMAND(
        	COMMAND ${PYTHON_EXECUTABLE}
        	ARGS setup.py build_ext --define HW_USE_OPENCL=2${HW_USE_CPU}
        	TARGET gpu
    		)
	elseif (OPENCL_CPU_SUPPORT)
    	    ADD_CUSTOM_COMMAND(
        	COMMAND ${PYTHON_EXECUTABLE}
        	ARGS setup.py build_ext --define HW_USE_OPENCL=3${HW_USE_CPU}
        	TARGET gpu
            )
	else ()
    	    ADD_CUSTOM_COMMAND(
        	COMMAND ${PYTHON_EXECUTABLE}
        	ARGS setup.py build_ext --define HW_USE_OPENCL=2,HW_USE_CPU=1
        	TARGET gpu
            )
	endif ()
    endif(OPENCL_GPU_SUPPORT)
    
    if (OPENCL_CPU_SUPPORT)
	if (OPENCL_GPU_SUPPORT)
    	    ADD_CUSTOM_TARGET(cpu)
	else (OPENCL_GPU_SUPPORT)
    	    ADD_CUSTOM_TARGET(cpu ALL)
	endif (OPENCL_GPU_SUPPORT)
	
    	ADD_DEPENDENCIES(cpu hst_opencl)
	    
	if (FALLBACK_CPU)
	    ADD_DEPENDENCIES(cpu hst_cpu)
	endif (FALLBACK_CPU)

	ADD_CUSTOM_COMMAND(
    	    COMMAND ${PYTHON_EXECUTABLE}
    	    ARGS setup.py build_ext --define HW_USE_OPENCL=1${HW_USE_CPU}
    	    TARGET cpu
    	)
	    
	set (PROVIDE_CPU_MODE FALSE)
    endif()

    if (PROVIDE_CPU_MODE)
        ADD_CUSTOM_TARGET(cpu)
    endif()
elseif (CUDA_FOUND)
    ADD_SUBDIRECTORY(hst_cuda)
    ADD_CUSTOM_TARGET(gpu ALL)
    ADD_DEPENDENCIES(gpu hst_cuda)

    if (DISABLE_DFI)
        set (PYBUILD_EXTRA_DEFINES "")
    else (DISABLE_DFI)
        ADD_SUBDIRECTORY(dfi_cuda)
        ADD_DEPENDENCIES(gpu dfi_cuda)
        set (PYBUILD_EXTRA_DEFINES ", PYHST_ENABLE_DFI=1")
    endif (DISABLE_DFI)

    if (FALLBACK_CPU)
	ADD_DEPENDENCIES(gpu hst_cpu)
    endif (FALLBACK_CPU)

    if (DISABLE_HYBRID)
        ADD_CUSTOM_COMMAND(
            COMMAND ${PYTHON_EXECUTABLE}
            ARGS setup.py build_ext --define HW_USE_CUDA=2${HW_USE_CPU}${PYBUILD_EXTRA_DEFINES}
            TARGET gpu
            )
    else (DISABLE_HYBDRID)
        ADD_CUSTOM_COMMAND(
            COMMAND ${PYTHON_EXECUTABLE}
            ARGS setup.py build_ext --define HW_USE_CUDA=2,HW_USE_CPU=1${PYBUILD_EXTRA_DEFINES}
            TARGET gpu
            )
    endif (DISABLE_HYBRID)

    if (PROVIDE_CPU_MODE)
        ADD_CUSTOM_TARGET(cpu)
    endif()
else()
    if (PROVIDE_CPU_MODE)
        ADD_CUSTOM_TARGET(cpu ALL)
    endif()
endif()

if (PROVIDE_CPU_MODE)
    ADD_SUBDIRECTORY(hst_cpu)
    ADD_DEPENDENCIES(cpu hst_cpu)

    ADD_CUSTOM_COMMAND(
        COMMAND ${PYTHON_EXECUTABLE}
        ARGS setup.py build_ext --define HW_USE_CPU=1
        TARGET cpu
        )
elseif (FALLBACK_CPU)
    ADD_SUBDIRECTORY(hst_cpu)
endif()

if (LS_EXECUTABLE AND SED_EXECUTABLE AND HEAD_EXECUTABLE AND FIND_EXECUTABLE)
    if (TARGET cpu)
        ADD_CUSTOM_COMMAND(
            COMMAND cmake
            ARGS -E remove ${CMAKE_SOURCE_DIR}/PyHST_c_CPU/PyHST_c.so
            COMMAND cmake
            ARGS -E create_symlink ../build/`${LS_EXECUTABLE} -qd ${CMAKE_SOURCE_DIR}/build/lib* | ${HEAD_EXECUTABLE} -n 1 | ${SED_EXECUTABLE} -e 's|.*/||'`/PyHST_c.so ${CMAKE_SOURCE_DIR}/PyHST_c_CPU/PyHST_c.so
            TARGET cpu
            )
    endif ()
    
    if (TARGET gpu)
        ADD_CUSTOM_COMMAND(
            COMMAND cmake
            ARGS -E remove ${CMAKE_SOURCE_DIR}/PyHST_c_CPU/PyHST_c.so
            COMMAND cmake
            ARGS -E create_symlink ../build/`${LS_EXECUTABLE} -qd ${CMAKE_SOURCE_DIR}/build/lib* | ${HEAD_EXECUTABLE} -n 1 | ${SED_EXECUTABLE} -e 's|.*/||'`/PyHST_c.so ${CMAKE_SOURCE_DIR}/PyHST_c_CPU/PyHST_c.so
            TARGET gpu
            )
    endif ()
endif()

ADD_SUBDIRECTORY(filters)
ADD_SUBDIRECTORY(fastedf)


# This is not working for me, therefore just deleting build
#ADD_CUSTOM_COMMAND(TARGET clean
#    COMMAND ${PYTHON_EXECUTABLE}
#    ARGS setup.py clean
#)
set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "build;PyHST_c_CPU/PyHST_c.so")


IF (UNIX)
    ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
    set(DISTCLEANED
        cmake\\.depends
        cmake\\.check_depends
        CMakeFiles
        cmake\\.check_CACHE
        cmake_install\\.cmake
        Makefile
        core
        core\\.[0-9a-zA-Z_]*
        gmon\\.out
        build
        .*\\.pyc
        .*~
        .*\\.so
        )

    set(DISTCLEANED_REGEX .*/\\\(CMakeCACHE\\.txt)
    FOREACH(ITEM ${DISTCLEANED})
        set(DISTCLEANED_REGEX "${DISTCLEANED_REGEX}\\|${ITEM}")
    ENDFOREACH(ITEM)
    set(DISTCLEANED_REGEX "${DISTCLEANED_REGEX}\\\)")
    #    message(${DISTCLEANED_REGEX})

    ADD_CUSTOM_COMMAND(
        DEPENDS clean
        COMMENT "distribution clean"
        COMMAND find
        ARGS    . -depth -regex '${DISTCLEANED_REGEX}' -exec ${RM_EXECUTABLE} -r {} "${DISTCLEANED_SLASH}${DISTCLEANED_SEMICOLON}"
        TARGET  distclean
        )

    ADD_CUSTOM_COMMAND(
        COMMENT "setting dummy makefile"
        COMMAND cmake
        ARGS -E copy Makefile.default Makefile
        TARGET distclean
        )
ENDIF(UNIX)