#*********************************************************************
#**                Image Component Library (ICL)                    **
#**                                                                 **
#** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
#**                         Neuroinformatics Group                  **
#** Website: www.iclcv.org and                                      **
#**          http://opensource.cit-ec.de/projects/icl               **
#**                                                                 **
#** File   : CMakeLists.txt                                         **
#** Module :                                                        **
#** Authors: Michael Goetting, Christof Elbrechter,                 **
#**          Sergius Gaulik                                         **
#**                                                                 **
#**                                                                 **
#** GNU LESSER GENERAL PUBLIC LICENSE                               **
#** This file may be used under the terms of the GNU Lesser General **
#** Public License version 3.0 as published by the                  **
#**                                                                 **
#** Free Software Foundation and appearing in the file LICENSE.LGPL **
#** included in the packaging of this file.  Please review the      **
#** following information to ensure the license requirements will   **
#** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
#**                                                                 **
#** The development of this software was supported by the           **
#** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
#** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
#** Forschungsgemeinschaft (DFG) in the context of the German       **
#** Excellence Initiative.                                          **
#**                                                                 **
#*********************************************************************

CMAKE_MINIMUM_REQUIRED(VERSION 2.8.2)
SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)

PROJECT(ICL)

# ---- cmake settings ----
INCLUDE(ICLHelperMacros)
INCLUDE(CheckArchitecture)
INCLUDE(InstallFilesRecursive)

SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

# ---- build type (debug/release) and opptions
IF(WIN32)
  IF(MSVC)
    SET(ICL_MSC_VER ${MSVC_VERSION})
  ENDIF(MSVC)
ENDIF(WIN32)

IF(MSVC)
  set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE TYPE INTERNAL FORCE)
ENDIF(MSVC)

IF(NOT WIN32)
  OPTION(ENABLE_NATIVE_BUILD_OPTION "Decide whether to use -march=native optimization flag" OFF)
  OPTION(ENABLE_SSEFPMATH_BUILD_OPTION "Decide whether to use -mfpmath=sse optimization flag" OFF)
  OPTION(ENABLE_FASTMATH_BUILD_OPTION "Decide whether to use -ffast-math optimization flag" OFF)
ENDIF()
OPTION(ENABLE_OPENMP_BUILD_OPTION "Decide whether to use -fopenmp optimization flag" OFF)

if(CMAKE_CXX_COMPILER MATCHES ".*clang\\+\\+$") # little ugly here
  set(ICL_DEACTIVATED_WARNING -Wno-internal-linkage-in-inline 
                              -Werror -Wno-\\#warnings 
                              -Wno-deprecated-declarations 
                              -Wno-uninitialized 
                              -Wno-overloaded-virtual)
else()
  set(ICL_DEACTIVATED_WARNING "")
endif()

IF(NOT CMAKE_BUILD_TYPE)
  MESSAGE(STATUS "No Specific build type specified: using Release")
  SET(CMAKE_BUILD_TYPE "Release")
ENDIF()

IF(MSVC)
  # Disable warnings about the use of old unsecure functions
  SET(ICL_COMPILER_FLAGS "/D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS")
  # Floating point model
  SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /fp:fast")
  # Enable intrinsic functions
  SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /Oi")
  # Enable function-level linking
  SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /Gy")
  # Set the debug information format
  SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /Zi")
  # Warning level
  #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
  # Change exception handling
  string(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
  # Multi-processor compilation
  #SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /MP")
  # Disable some warnings
  SET(ICL_COMPILER_FLAGS "${ICL_COMPILER_FLAGS} /wd4201 /wd4244 /wd4251 /wd4275 /wd4290 /wd4510 /wd4514 /wd4610 /wd4710 /wd4711 /wd4800 /wd4820")
  # Conflicts with other libraries
  #SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NODEFAULTLIB:libc /NODEFAULTLIB:msvcrtd")
  # Generate debug information
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /debug")
  
  SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} ${ICL_COMPILER_FLAGS}")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ICL_COMPILER_FLAGS}")
  
  IF(ENABLE_OPENMP_BUILD_OPTION)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /openmp -DUSE_OPENMP")
  ENDIF()
ELSE(MSVC)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall ${ICL_DEACTIVATED_WARNING}")
  SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3")
  SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")

  IF(ENABLE_OPENMP_BUILD_OPTION)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp -DUSE_OPENMP")
  ENDIF()
  IF(ENABLE_NATIVE_BUILD_OPTION)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
  ENDIF()
  IF(ENABLE_FASTMATH_BUILD_OPTION)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
  ENDIF()
  IF(ENABLE_SSEFPMATH_BUILD_OPTION)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=sse")
  ENDIF()
ENDIF(MSVC)

# ---- global definitions ----
# todo: add "-debug" postfix here and there!
SET(ICL_VERSION_MAJOR "9" CACHE STRING "Major project version part")
SET(ICL_VERSION_MINOR "5" CACHE STRING "Minor project version part")
SET(ICL_VERSION_PATCH "0" CACHE STRING "Patch project version part")


SET(ICL_NAME                   icl)
SET(PROJECT_VERSION            "${ICL_VERSION_MAJOR}.${ICL_VERSION_MINOR}.${ICL_VERSION_PATCH}")
SET(SO_VERSION                 "${ICL_VERSION_MAJOR}.${ICL_VERSION_MINOR}")
SET(INSTALL_PATH_PREFIX        "${ICL_NAME}-${SO_VERSION}")
SET(BINARY_PREFIX              "${ICL_NAME}-")
SET(RESOURCE_DIR               "etc/${INSTALL_PATH_PREFIX}")

SET(ICL_CMAKE_MODULE_PATH "share/${INSTALL_PATH_PREFIX}/cmake/Modules")

CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/ICLUtils/src/ICLVersion.h.in ${CMAKE_BINARY_DIR}/src/ICLUtils/ICLVersion.h)

# ---- Check Architecture ----
CURRENT_ARCHITECTURE(ICL_BUILD_ARCH)

IF(${ICL_BUILD_ARCH} EQUAL "64_BIT_FOUND")
  SET(ICL_64BIT TRUE)
  ADD_ICL_DEFINITIONS(-DICL_64BIT)
  #SET_PROPERTY(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS ON)
ELSE()
  SET(ICL_32BIT TRUE)
  ADD_ICL_DEFINITIONS(-DICL_32BIT)
ENDIF()

# --- global compiler flags ---
IF(UNIX)
  ADD_ICL_DEFINITIONS(-DICL_SYSTEM_LINUX)
ELSEIF(APPLE)
  ADD_ICL_DEFINITIONS(-DICL_SYSTEM_APPLE)
ELSEIF(WIN32)
  ADD_ICL_DEFINITIONS(-DICL_SYSTEM_WINDOWS)
ENDIF()

# ---- User options ----
OPTION(BUILD_WITH_OPENCV "Link against OpenCV and provide OpenCV image convertion functions" OFF)
OPTION(BUILD_WITH_QT "Provides GUI and image visualization framework (needs OPENGL)" OFF)
OPTION(BUILD_WITH_OPENGL "Linked to BUILD_WITH_QT" OFF)
OPTION(BUILD_WITH_RSB "Link against the RSB framework for network-based image transfer (needs PROTOBUF)" OFF)
OPTION(BUILD_WITH_PROTOBUF "Needed for RSB-based image transfer" OFF)
OPTION(BUILD_WITH_EIGEN3 "Uses Eigen3 to speed up several algorithms" OFF)
OPTION(BUILD_WITH_IPP "Link against Intel IPP for general speedup" OFF)
OPTION(BUILD_WITH_MKL "Link against Intel MKL to speed up several mathematic fuctions" OFF)
OPTION(BUILD_WITH_MESASR "Link against libmesasr to provide SwissRanger camera support" OFF)
OPTION(BUILD_WITH_IMAGEMAGICK "Use ImageMagick to provide I/O for many common image formats" OFF)
OPTION(BUILD_WITH_LIBAV "Use libav to provide video encoding for many common video formats" OFF)
OPTION(BUILD_WITH_LIBDC "Use libdc to provide FireWire-Camera support" OFF)
OPTION(BUILD_WITH_LIBFREENECT "Use libfreenect to grab from Kinect Devices" OFF)
OPTION(BUILD_WITH_LIBFREENECT2 "Use experimental libfreenect2 dependency to grab from Kinect2 Devices" OFF)
OPTION(BUILD_WITH_XINE "Provides a libxine base Video-Grabber backend" OFF)
IF(NOT WIN32)
OPTION(BUILD_WITH_DL "Link against libdl to provide dynamic runtime linking support" ON)
ENDIF(NOT WIN32)
OPTION(BUILD_WITH_V4L "Provides V4L2 grabber backend for USB-Cameras" OFF)
OPTION(BUILD_WITH_LIBUSB "Provides grabber backend for the pixelsense device (microsoft surface)" OFF)
OPTION(BUILD_WITH_ZMQ "Provides Zero-MQ-based network grabber and image output" OFF)
OPTION(BUILD_WITH_PYLON "Link against the basler Pylon package to support GIG-E cameras" OFF)
OPTION(BUILD_WITH_OPENCL "Uses OpenCL to speed up several algorithms" OFF)
OPTION(BUILD_WITH_OPENNI "Links against OpenNI to grab from Kinect devices" OFF)
OPTION(BUILD_WITH_PCL "Link against PCL to provide a compatibility layer to PCL point clouds" OFF)
OPTION(BUILD_WITH_SSE "Decide if all SSE intrinsics shall be used to speed up many support functions" ON)
OPTION(BUILD_WITH_SSE2 "Decide if SSE2 and lower intrinsics shall be used to speed up many support functions" OFF)
OPTION(BUILD_WITH_SSE3 "Decide if SSE3 and lower intrinsics shall be used to speed up many support functions" OFF)
OPTION(BUILD_WITH_SSSE3 "Decide if SSSE3 and lower intrinsics shall be used to speed up many support functions" OFF)
OPTION(BUILD_WITH_BULLET "Provides physics simulation. Needs the bullet physics engine" OFF)
OPTION(BUILD_WITH_RST "Link against the RST framework for message definitions (needs PROTOBUF)" OFF)
OPTION(BUILD_WITH_RSC "Link against the RSC framework for message definitions (needs RST)" OFF)
OPTION(BUILD_WITH_XIAPI "Link against the libm3api, e.g. used for Ximea Cameras" OFF)
OPTION(BUILD_WITH_LIBIRIMAGER "Link against the libirimager needed for Optris' IR cameras (requires LIBUDEV and V4L)" OFF)
OPTION(BUILD_WITH_LIBUDEV "Link against the libudev (needed the LIBIRIMAGER dependency)" OFF)

OPTION(BUILD_EXAMPLES "Decide if examples shall be build or not" OFF)
OPTION(BUILD_DEMOS "Decide if demos shall be build or not" OFF)
OPTION(BUILD_APPS "Decide if applications shall be build or not" OFF)

# ---- Dependency handling ----
INCLUDE(ICLFindPackage)

IF(WIN32)
  set(CMAKE_FIND_LIBRARY_SUFFIXES .lib)
ELSE(WIN32)
  set(CMAKE_FIND_LIBRARY_SUFFIXES .so)
ENDIF(WIN32)

IF(WIN32)
  SET(PKG_SEARCH_PATHS "")

  IF(ICL_64BIT)
    SET(ARCH_DEPENDENT_LIB_PATHS "lib/x64;lib/msvc_x64")
  ELSE(ICL_64BIT)
    SET(ARCH_DEPENDENT_LIB_PATHS "lib/x86;lib/msvc;lib/Win32")
  ENDIF(ICL_64BIT)
ELSE(WIN32)
  SET(PKG_SEARCH_PATHS "/usr;/usr/local")

  IF(ICL_64BIT)
    SET(ARCH_DEPENDENT_LIB_PATHS "lib/x86_64-linux-gnu;lib/intel64")
  ELSE(ICL_64BIT)
    SET(ARCH_DEPENDENT_LIB_PATHS "lib/i386-linux-gnu;lib/ia32")
  ENDIF(ICL_64BIT)
ENDIF(WIN32)

IF(WIN32)
    ICL_FIND_PACKAGE(NAME Pthreads
                     HEADERS "pthread.h"
                     LIBS "pthreadVC2")
    IF(PTHREADS_FOUND)
      LIST(APPEND REQUIRED_LIBRARIES_LIST ${PTHREADS_LIBRARIES})
    ENDIF()
ELSE()
    FIND_PACKAGE(Threads REQUIRED)
    IF(Threads_FOUND)
      LIST(APPEND REQUIRED_LIBRARIES_LIST ${CMAKE_THREAD_LIBS_INIT})
    ENDIF()
ENDIF()

IF(WIN32)
  LIST(APPEND REQUIRED_LIBRARIES_LIST zlib)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBZ)
ELSE()
  FIND_PACKAGE(ZLIB REQUIRED)
ENDIF()
IF(ZLIB_FOUND)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBZ)
  LIST(APPEND REQUIRED_LIBRARIES_LIST ${ZLIB_LIBRARIES})
ENDIF()

IF(WIN32)
  LIST(APPEND REQUIRED_LIBRARIES_LIST libjpeg)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBJPEG)
ELSE()
  FIND_PACKAGE(JPEG REQUIRED)
ENDIF()
IF(JPEG_FOUND)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBJPEG)
  LIST(APPEND REQUIRED_LIBRARIES_LIST ${JPEG_LIBRARIES})
ENDIF()

IF(WIN32)
  LIST(APPEND REQUIRED_LIBRARIES_LIST libpng)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBPNG)
ELSE()
  FIND_PACKAGE(PNG REQUIRED)
ENDIF()
IF(PNG_FOUND)
  ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBPNG)
  LIST(APPEND REQUIRED_LIBRARIES_LIST ${PNG_LIBRARIES})
ENDIF()

IF(NOT WIN32)
  ICL_FIND_PACKAGE(NAME DL HEADERS "dlfcn.h" LIBS "dl")
  IF(DL_FOUND)
    LIST(APPEND REQUIRED_LIBRARIES_LIST ${DL_LIBRARIES})
  ENDIF()
ENDIF()

IF(BUILD_WITH_IPP)
  IF(ICL_64BIT)
    SET(_IPP_LIB_SUF "ipp/lib/intel64")
  ELSE(ICL_64BIT)
    SET(_IPP_LIB_SUF "ipp/lib/ia32")
  ENDIF(ICL_64BIT)

  ICL_FIND_PACKAGE(NAME IPP
    HEADERS "ipp.h"
    LIBS "ippcore;ippi;ipps;ippcv;ippm;ippcc;iomp5"
    PATHS "/opt/IPP"
    HEADER_PATH_SUFFIXES "ipp/include"
    LIB_PATH_SUFFIXES "${_IPP_LIB_SUF}")
  
  IF(IPP_FOUND)
    IF(EXISTS "${IPP_INCLUDE_DIRS}/ippversion.h")
      get_ipp_version(${IPP_INCLUDE_DIRS})
    ENDIF()
    ADD_ICL_DEFINITIONS(-DICL_HAVE_IPP)
  ENDIF()
ENDIF()


IF(BUILD_WITH_MKL)
  IF(ICL_64BIT)
    SET(_MKL_LIB "mkl_intel_lp64")
    SET(_MKL_LIB_SUF "mkl/lib/intel64")
  ELSE(ICL_64BIT)
    IF(WIN32)
      SET(_MKL_LIB "mkl_intel_c")
    ELSE(WIN32)
      SET(_MKL_LIB "mkl_intel")
    ENDIF(WIN32)
    SET(_MKL_LIB_SUF "mkl/lib/ia32")
  ENDIF(ICL_64BIT)
  ICL_FIND_PACKAGE(NAME MKL
                   HEADERS "mkl_types.h"
                   LIBS "${_MKL_LIB};mkl_intel_thread;mkl_core;iomp5"
                   PATHS "/opt/MKL;/opt/MKL/mkl"
                   HEADER_PATH_SUFFIXES "mkl/include"
                   LIB_PATH_SUFFIXES "${_MKL_LIB_SUF}")
ENDIF()

IF(BUILD_WITH_OPENCL)
  FIND_PACKAGE(OpenCL REQUIRED)
  IF(OPENCL_FOUND)
	SET(CMAKE_CXX_FLAGS "-msse2 ${CMAKE_CXX_FLAGS}")
  ENDIF()
ENDIF()

IF(BUILD_WITH_EIGEN3)
  ICL_FIND_PACKAGE(NAME Eigen3
                   HEADERS "Eigen/Eigen"
                   HEADER_PATH_SUFFIXES "include/eigen3")
ENDIF()

IF(BUILD_WITH_OPENNI)
  #ICL_FIND_PACKAGE(NAME OpenNI
  #                 HEADERS "XnOpenNI.h"
  #                 LIBS "OpenNI"
  #                 HEADER_PATH_SUFFIXES "include/ni")
  # after testing the above function call the 4 lines below and FindOpenNI.cmake can be removed
  FIND_PACKAGE(OpenNI)
  IF(OpenNI_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENNI)
  ENDIF()
ENDIF()

IF(BUILD_WITH_OPENCV)
  SET(OPENCV_FEATURES_2D_FOUND "FALSE")
  FIND_PACKAGE(OpenCV REQUIRED)
  IF(OPENCV_FOUND)
    SET(OpenCV_FOUND "TRUE")
  ENDIF()
  IF(OpenCV_FOUND)
    SET(OPENCV_FOUND "TRUE")
    ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENCV)
    ADD_ICL_DEFINITIONS(-DQWT_DLL)
    # don't show it in the GUI
    MARK_AS_ADVANCED(OPENCV_FOUND)
    MARK_AS_ADVANCED(OpenCV_FOUND)

    IF(${OpenCV_OLD_LIBS_NOT_FOUND} STREQUAL "FALSE")
      ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENCV_OLD_STYLE)
    ELSE()
      ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENCV_NEW_STYLE)
      # we need at least opencv 2.4 for the ORB-feature interface we want to use
      IF(((NOT OPENCV_VERSION_MAJOR LESS 2) AND (NOT OPENCV_VERSION_MINOR LESS 4)) 
          OR (OPENCV_VERSION_MAJOR GREATER 2))
       MESSAGE(STATUS "OpenCV >= 2.4.x detected, adding ORB feature detector")
       ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENCV_FEATURES_2D)
       SET(OPENCV_FEATURES_2D_FOUND "TRUE")
     ELSE()
       MESSAGE(STATUS "OpenCV < 2.4.x detected, ommitting ORB feature detector")
     ENDIF()
    ENDIF()
  ENDIF()
ENDIF()

IF(BUILD_WITH_IMAGEMAGICK)
  FIND_PACKAGE(ImageMagick REQUIRED COMPONENTS Magick++)
  IF(ImageMagick_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_IMAGEMAGICK)
  ENDIF()
ENDIF()

IF(BUILD_WITH_XIAPI)
 ICL_FIND_PACKAGE(NAME XIAPI
                  HEADERS "m3api/xiApi.h"
                  LIBS "m3api")
  IF(XIAPI_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_XIAPI)
  ENDIF()
ENDIF()

IF(BUILD_WITH_LIBIRIMAGER)
  IF(NOT BUILD_WITH_LIBUDEV)
    MESSAGE(SEND_ERROR "BUILD_WITH_LIBIRIMAGER was defined, but BUILD_WITH_LIBUDEV wasn't (udev is needed mandatorily for LIBIRIMAGER)")
  ENDIF()

  IF(NOT BUILD_WITH_V4L)
    MESSAGE(SEND_ERROR "BUILD_WITH_LIBIRIMAGER was defined, but BUILD_WITH_V4L wasn't (video for linus is needed mandatorily for LIBIRIMAGER)")
  ENDIF()

  ICL_FIND_PACKAGE(NAME LIBIRIMAGER
                  HEADERS "libirimager/IRImager.h"
                  LIBS "irimager;irimageprocessing")

  ICL_FIND_PACKAGE(NAME LIBUDEV
                  LIBS "udev")
  
  IF(LIBIRIMAGER_FOUND AND LIBUDEV_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBIRIMAGER -DICL_HAVE_LIBUDEV)
  ELSE()
    SET(HAVE_LIBIRIMAGER FALSE)
    SET(HAVE_LIBUDEV FALSE)
  ENDIF()
ENDIF()


IF(BUILD_WITH_MESASR)
  ICL_FIND_PACKAGE(NAME MesaSR
                   HEADERS "libMesaSR.h"
                   LIBS "mesasr"
                   PATHS "/opt/MESASR")
  IF(MesaSR_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBMESAR)
  ENDIF()
ENDIF()

IF(BUILD_WITH_LIBDC)
  FIND_PACKAGE(LibDC REQUIRED)
  #ICL_FIND_PACKAGE(NAME LibDC
  #                 HEADERS "dc1394/dc1394.h"
  #                 LIBS "dc1394")
  IF(LIBDC_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBDC)
  ENDIF()
ENDIF()

IF(BUILD_WITH_LIBUSB)
  IF(WIN32)
    ICL_FIND_PACKAGE(NAME LIBUSB
                     HEADERS "usb.h;lusb0_usb.h"
                     LIBS "libusb"
                     PATHS "/opt/MESASR")
  ELSE(WIN32)
    ICL_FIND_PACKAGE(NAME LIBUSB
                     HEADERS "usb.h;lusb0_usb.h"
                     LIBS "usb")
    IF(NOT LIBUSB_FOUND)
      ICL_FIND_PACKAGE(NAME LIBUSB
        HEADERS "usb.h"
        HEADER_PATH_SUFFIXES "include/libusb-1.0"
        LIBS "usb")
    ENDIF()
  ENDIF(WIN32)
ENDIF()

IF(BUILD_WITH_V4L)
  FIND_PACKAGE(V4L REQUIRED)
  IF(V4L_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_VIDEODEV)
  ENDIF()
ENDIF()

IF(BUILD_WITH_ZMQ)
  ICL_FIND_PACKAGE(NAME ZMQ
                   HEADERS "zmq.hpp"
                   LIBS "zmq")
ENDIF()


IF(BUILD_WITH_XINE)
  ICL_FIND_PACKAGE(NAME Xine
                   HEADERS "xine.h"
                   LIBS "xine")
ENDIF()

IF(BUILD_WITH_QT)
  SET(QT_ROOT QT_ROOT CACHE PATH "Root directory of Qt5")
  IF(WIN32)
    FIND_PACKAGE(WindowsSDK REQUIRED)
    set(CMAKE_LIBRARY_PATH "${WINDOWSSDK_DIRS}/Lib")
    if(POLICY CMP0020)
      cmake_policy(SET CMP0020 NEW)
    endif()
    IF(ICL_64BIT)
      SET(_GLEW_LIB_SUF "lib/Release/x64")
    ELSE(ICL_64BIT)
      SET(_GLEW_LIB_SUF "lib/Release/Win32")
    ENDIF(ICL_64BIT)
    ICL_FIND_PACKAGE(NAME GLEW
                     HEADERS "GL/glew.h"
                     LIBS "glew32"
                     LIB_PATH_SUFFIXES ${_GLEW_LIB_SUF})
  ELSE(WIN32)
    ICL_FIND_PACKAGE(NAME GLEW
                     HEADERS "GL/glew.h"
                     LIBS "GLEW")
  ENDIF(WIN32)
  FIND_PACKAGE(OpenGL REQUIRED)
  FIND_PACKAGE(Qt5Widgets REQUIRED HINTS ${QT_ROOT})
  FIND_PACKAGE(Qt5OpenGL REQUIRED HINTS ${QT_ROOT})
  FIND_PACKAGE(Qt5Core REQUIRED HINTS ${QT_ROOT})
  IF(Qt5Widgets_FOUND AND Qt5Core_FOUND)
    IF(Qt5OpenGL_FOUND)
      SET(QT4_FOUND TRUE)
      SET(QT_FOUND TRUE)
      #set(CMAKE_AUTOMOC ON)
      #set(CMAKE_INCLUDE_CURRENT_DIR ON)
      add_definitions(${Qt5Widgets_DEFINITIONS})
      IF(NOT WIN32)
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
      ENDIF(NOT WIN32)
      
      # This creates full library paths from Qt's colon separated paths. 
      # Colon separated Qt library paths only work when Qt's find package was called.
      # This is not necessarily done in projects linking against icl so we need full
      # Paths here.
      IF(WIN32)
        get_target_property(ICLQt5CoreLibAbs Qt5::Core IMPORTED_IMPLIB_RELEASE)
        get_target_property(ICLQt5GuiLibAbs Qt5::Gui IMPORTED_IMPLIB_RELEASE)
        get_target_property(ICLQt5WidgetsLibAbs Qt5::Widgets IMPORTED_IMPLIB_RELEASE)
        get_target_property(ICLQt5OpenGLLibAbs Qt5::OpenGL IMPORTED_IMPLIB_RELEASE)
      ELSE(WIN32)
        get_target_property(ICLQt5CoreLib Qt5::Core IMPORTED_SONAME_RELEASE)
        get_target_property(ICLQt5GuiLib Qt5::Gui IMPORTED_SONAME_RELEASE)
        get_target_property(ICLQt5WidgetsLib Qt5::Widgets IMPORTED_SONAME_RELEASE)
        get_target_property(ICLQt5OpenGLLib Qt5::OpenGL IMPORTED_SONAME_RELEASE)
        get_target_property(_QT5CORE_LOCATION Qt5::Core LOCATION)
        IF(CMAKE_VERSION VERSION_LESS 2.8.12)
          get_filename_component(_QT5CORE_ABSOLUTE ${_QT5CORE_LOCATION} PATH)
        ELSE()
          get_filename_component(_QT5CORE_ABSOLUTE ${_QT5CORE_LOCATION} DIRECTORY)
        ENDIF()
        MESSAGE(STATUS "ICLQt5CoreLib : ${ICLQt5CoreLib}")

        # For some reason cmake does not add library paths to rpath when they end 
        # with a number like libQt5Core.so.5. Changing the linked libraries to the
        # simple .so resolves this problem.
        STRING(REGEX REPLACE "[.]so([.][0-9])+" ".so" ICLQt5CoreLibAbs "${_QT5CORE_ABSOLUTE}/${ICLQt5CoreLib}")
        STRING(REGEX REPLACE "[.]so([.][0-9])+" ".so" ICLQt5OpenGLLibAbs "${_QT5CORE_ABSOLUTE}/${ICLQt5OpenGLLib}")
        STRING(REGEX REPLACE "[.]so([.][0-9])+" ".so" ICLQt5WidgetsLibAbs "${_QT5CORE_ABSOLUTE}/${ICLQt5WidgetsLib}")
        STRING(REGEX REPLACE "[.]so([.][0-9])+" ".so" ICLQt5GuiLibAbs "${_QT5CORE_ABSOLUTE}/${ICLQt5GuiLib}")
      ENDIF(WIN32)

      SET(Qt5_LIBRARIES ${ICLQt5CoreLibAbs})
      LIST(APPEND Qt5_LIBRARIES ${ICLQt5OpenGLLibAbs})
      LIST(APPEND Qt5_LIBRARIES ${ICLQt5WidgetsLibAbs})
      LIST(APPEND Qt5_LIBRARIES ${ICLQt5GuiLibAbs})

      ADD_ICL_DEFINITIONS(-DICL_HAVE_QT)
      ADD_ICL_DEFINITIONS(-DICL_HAVE_OPENGL)
      ADD_ICL_DEFINITIONS(-DQWT_DLL)
    ENDIF()
  ENDIF()
ENDIF()

IF(BUILD_WITH_LIBFREENECT)
  ICL_FIND_PACKAGE(NAME LibFreenect
                   HEADERS "libfreenect.h"
                   LIBS "freenect;freenect_sync"
                   HEADER_PATH_SUFFIXES "include/libfreenect") 
ENDIF()

IF(BUILD_WITH_LIBFREENECT2)
  IF(LIBFREENECT2_ROOT)
    SET(LIBFREENECT2_GLFW3_ROOT ${LIBFREENECT2_ROOT})
    SET(LIBFREENECT2_LIBUSB_ROOT ${LIBFREENECT2_ROOT})
  ENDIF()

  ICL_FIND_PACKAGE(NAME LibFreenect2
                   HEADERS "libfreenect2/opengl.h;libfreenect2/libfreenect2.hpp;libfreenect2/frame_listener_impl.h"
                   LIBS "freenect2"
                   HEADER_PATH_SUFFIXES "examples/protonect/include"
                   LIB_PATH_SUFFIXES "examples/protonect/lib") 

  ICL_FIND_PACKAGE(NAME LibFreenect2_GLFW3
                   HEADERS "GLFW/glfw3.h"
                   LIBS "glfw"
                   HEADER_PATH_SUFFIXES "depends/glfw/include"
                   LIB_PATH_SUFFIXES "depends/glfw/lib") 

  ICL_FIND_PACKAGE(NAME LibFreenect2_LIBUSB
                   HEADERS "libusb-1.0/libusb.h"
                   LIBS "usb-1.0"
                   HEADER_PATH_SUFFIXES "depends/libusb/include"
                   LIB_PATH_SUFFIXES "depends/libusb/lib") 


  IF(LIBFREENECT2_FOUND AND LIBFREENECT2_GLFW3_FOUND AND LIBFREENECT2_LIBUSB_FOUND)
    LIST(APPEND LIBFREENECT2_LIBRARIES ${LIBFREENECT2_GLFW3_LIBRARIES} ${LIBFREENECT2_LIBUSB_LIBRARIES})
    LIST(APPEND LIBFREENECT2_INCLUDE_DIRS ${LIBFREENECT2_GLFW3_INCLUDE_DIRS} ${LIBFREENECT2_LIBUSB_INCLUDE_DIRS})
    ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBFREENECT2)
  ENDIF()
ENDIF()


IF(BUILD_WITH_PYLON)
  FIND_PACKAGE(Pylon REQUIRED)
  IF(PYLON_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_PYLON)
  ENDIF()  
ENDIF()

IF(BUILD_WITH_PCL)
  IF(BUILD_WITH_PCL_OPTIONAL)
    FIND_PACKAGE(PCL 1.6 COMPONENTS kdtree common octree search QUIET)
  ELSE()
    FIND_PACKAGE(PCL 1.6 REQUIRED COMPONENTS kdtree common octree search QUIET)
  ENDIF()
  # io requires openni aswell !!
  # FIND_PACKAGE(PCL REQUIRED) ?? 
  IF(PCL_FOUND)
    MESSAGE(STATUS "Found PCL: ${PCL_INCLUDE_DIRS} ${PCL_LIBRARIES}")
    # workaround aroud issue that PCL_LIBRARIES contains
    # tokens optimized pthread and debug
    SET(PCL_LIBRARIES_PC ${PCL_LIBRARIES})
    LIST(REMOVE_DUPLICATES PCL_LIBRARIES_PC)
    LIST(REMOVE_ITEM PCL_LIBRARIES_PC debug)
    LIST(REMOVE_ITEM PCL_LIBRARIES_PC optimized)
    LIST(REMOVE_ITEM PCL_LIBRARIES_PC pthread)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_PCL)
  ELSE()
    IF(BUILD_WITH_PCL_OPTIONAL)
      MESSAGE(STATUS "Cloud NOT find OPTIONAL PCL (continuing...)")
    ELSE()
      MESSAGE(SEND_ERROR "Could NOT find PCL")
    ENDIF()
  ENDIF()  
ENDIF()

# Why does it have to be before the RSB stuff?
IF(BUILD_WITH_RST)
  IF(NOT BUILD_WITH_PROTOBUF)
    MESSAGE(FATAL_ERROR "Option BUILD_WITH_RST was defined, but BUILD_WITH_PROTOBUF was not defined (these options belong together, so either specify both or none of them)")
  ENDIF()
  IF(NOT BUILD_WITH_RSC)
    MESSAGE(FATAL_ERROR "Option BUILD_WITH_RST was defined, but BUILD_WITH_RSC was not defined (these options belong together, so either specify both or none of them)")
  ENDIF()
  
  IF(RST_ROOT)
    FIND_PACKAGE(RST COMPONENTS sandbox PATHS ${RST_ROOT} NO_DEFAULT_PATH QUIET)
  ELSE()
    FIND_PACKAGE(RST COMPONENTS sandbox QUIET)
  ENDIF()


  IF(RST_FOUND)
    set(HAVE_ALL_PROTOS TRUE)
    foreach(proto rst/math/Vec3DFloat.proto rst/geometry/PolygonalPatch3D.proto rst/geometry/Primitive3DFloatSet.proto)
      LIST(FIND STABLE_PROTOS_REL proto/stable/${proto} _HAVE_STABLE_PROTO)
      LIST(FIND SANDBOX_PROTOS_REL proto/sandbox/${proto} _HAVE_SANDBOX_PROTO)
      if((_HAVE_STABLE_PROTO LESS 0) AND (_HAVE_SANDBOX_PROTO LESS 0))
	LIST(APPEND RST_MISSING ${proto})
	set(HAVE_ALL_PROTOS FALSE)
      endif()
    endforeach()
  else()
    SET(RST_MISSING "RST package")
  endif()

  IF(RST_FOUND AND HAVE_ALL_PROTOS)
    MESSAGE(STATUS "Found RST: ${RST_INCLUDE_DIRS} ${RST_LIBRARIES}")
    
    IF(RSC_ROOT)
      FIND_PACKAGE(RSC PATHS ${RSC_ROOT} NO_DEFAULT_PATH QUIET)
    ELSE()
      FIND_PACKAGE(RSC PATHS QUIET)
    ENDIF()
    

    IF(RSC_FOUND)
      ADD_ICL_DEFINITIONS(-DICL_HAVE_RST ${RST_CFLAGS})      
      ADD_ICL_DEFINITIONS(-DICL_HAVE_RSC ${RSC_CFLAGS})      
    ELSE()
      IF(BUILD_WITH_RSC_OPTIONAL)
        MESSAGE(STATUS "Cloud NOT find OPTIONAL RSC (missing:  continuing...)")
      ELSE()
        MESSAGE(SEND_ERROR "Could NOT find RST")
      ENDIF()
    ENDIF()

  ELSE()
    SET(RST_FOUND FALSE)
    IF(BUILD_WITH_RST_OPTIONAL)
      MESSAGE(STATUS "Cloud NOT find OPTIONAL RST (missing: ${RST_MISSING}, continuing...)")
    ELSE()
      MESSAGE(SEND_ERROR "Could NOT find RST (missing: ${RST_MISSING})")
    ENDIF()
  ENDIF()
ENDIF()

MESSAGE(STATUS ${RST_LIBRARIES_PC})

IF(BUILD_WITH_RSB)
  IF(NOT BUILD_WITH_PROTOBUF)
    MESSAGE(FATAL_ERROR "Option BUILD_WITH_RSB was defined, but BUILD_WITH_PROTOBUF was not defined (these options belong together, so either specify both or none of them)")
  ENDIF()
  FIND_PACKAGE(RSB REQUIRED HINTS ${RSB_ROOT} QUIET)
  IF(WIN32)
    FIND_PACKAGE(WinProtobuf REQUIRED)
  ELSE()
    IF(PROTOBUF_ROOT)
      FIND_PACKAGE(Protobuf REQUIRED HINTS ${PROTOBUF_ROOT} QUIET)
    ELSE()
      FIND_PACKAGE(Protobuf REQUIRED QUIET)
    ENDIF()
  ENDIF()

  IF(RSB_FOUND AND PROTOBUF_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_RSB)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_PROTOBUF)
    
    LIST(APPEND RSB_RSC_AND_PROTOBUF_LIBRARIES_PC ${RSB_LIBRARIES})
    LIST(APPEND RSB_RSC_AND_PROTOBUF_LIBRARIES_PC ${PROTOBUF_LIBRARIES})
    IF(WIN32)
      LIST(APPEND RSB_RSC_AND_PROTOBUF_LIBRARIES_PC ${BOOST_LIBRARIES})
    ENDIF(WIN32)
    LIST(REMOVE_DUPLICATES RSB_RSC_AND_PROTOBUF_LIBRARIES_PC)
    LIST(REMOVE_ITEM RSB_RSC_AND_PROTOBUF_LIBRARIES_PC debug)
    LIST(REMOVE_ITEM RSB_RSC_AND_PROTOBUF_LIBRARIES_PC optimized)
    LIST(REMOVE_ITEM RSB_RSC_AND_PROTOBUF_LIBRARIES_PC pthread)
    MESSAGE(STATUS "Found RSB: ${RSB_INCLUDE_DIRS} ${RSB_LIBRARIES}")
    MESSAGE(STATUS "Found PROTOBUF: ${PROTOBUF_INCLUDE_DIRS} ${PROTOBUF_LIBRARIES}")
  ELSE()
    IF(NOT RSB_FOUND)
      IF(BUILD_WITH_RSB_OPTIONAL)
        MESSAGE(STATUS "Cloud NOT find OPTIONAL RSB (continuing...)")
      ELSE()
        MESSAGE(SEND_ERROR "Could NOT find RSB")
      ENDIF()
    ELSE()
      IF(NOT PROTOBUF_FOUND)
        MESSAGE(SEND_ERROR "Could NOT find PROTOBUF")
        IF(BUILD_WITH_PROTOBUF_OPTIONAL)
          IF(BUILD_WITH_RSB_OPTIONAL)
            MESSAGE(STATUS "Cloud NOT find OPTIONAL PROTOBUF (continuing...)")
          ELSE()
            MESSAGE(SEND_ERROR "Defining BUILD_WITH_PROTOBUF_OPTIONAL=TRUE is not possible as RSB needs PROTOBUF mandatorily (define BUILD_WITH_RSB_OPTIONAL=TRUE aswell to achieve a real optional RSB dependency)")
          ENDIF()
        ENDIF()
      ENDIF()
    ENDIF()
    SET(RSB_FOUND FALSE)
    SET(PROTOBUF_FOUND FALSE)
  ENDIF()  
ENDIF()

MESSAGE(STATUS ${RSB_RSC_AND_PROTOBUF_LIBRARIES_PC})

IF(BUILD_WITH_SSE)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE2)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE3)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSSE3)
ENDIF()

IF(BUILD_WITH_SSE2)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE2)
ENDIF()

IF(BUILD_WITH_SSE3)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE2)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE3)
ENDIF()

IF(BUILD_WITH_SSE3)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE2)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSE3)
  ADD_ICL_DEFINITIONS(-DICL_USE_SSSE3)
ENDIF()

IF(BUILD_WITH_BULLET)
  ICL_FIND_PACKAGE(NAME Bullet
                   HEADERS "BulletDynamics/Dynamics/btRigidBody.h;BulletSoftBody/btSoftBody.h;BulletCollision/NarrowPhaseCollision/btPointCollector.h;BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h;BulletSoftBody/btSoftRigidDynamicsWorld.h;BulletCollision/CollisionShapes/btBoxShape.h;BulletCollision/CollisionShapes/btCompoundShape.h"
                   LIBS "LinearMath;BulletCollision;BulletDynamics;BulletSoftBody"
                   HEADER_PATH_SUFFIXES "include/bullet"
                   LIB_PATH_SUFFIXES "lib") 
#  FIND_PACKAGE(BULLET REQUIRED)
  IF(BULLET_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_BULLET)
  ENDIF()
ENDIF()

IF(BUILD_WITH_LIBAV)
  ICL_FIND_PACKAGE(NAME libav
                   HEADERS "libavcodec/avcodec.h;libavformat/avfornat.h;libswscale/swscale.h"
                   LIBS "avcodec;avformat;avutil;avresample;swscale;avdevice;"
                   HEADER_PATH_SUFFIXES "include/avcodec;include/avformat;include/avdevice;include/avfilter;include/avutil;include/avresample;include/swscale")
  IF(LIBAV_FOUND)
    ADD_ICL_DEFINITIONS(-DICL_HAVE_LIBAV)
  ENDIF()
ENDIF()

CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/ICLUtils/src/ICLConfig.h.in ${CMAKE_BINARY_DIR}/src/ICLUtils/ICLConfig.h)

# ---- OS system include directories ----
IF(WIN32)
INCLUDE_DIRECTORIES(BEFORE SYSTEM ${ZLIB_INCLUDE_DIRS}
                                  ${JPEG_INCLUDE_DIR}
                                  ${PTHREADS_INCLUDE_DIRS}
                                  ${PNG_INCLUDE_DIRS}
                                  ${ImageMagick_INCLUDE_DIRS})
ELSE()
INCLUDE_DIRECTORIES(BEFORE SYSTEM ${ZLIB_INCLUDE_DIRS}
                                  ${JPEG_INCLUDE_DIR}
                                  ${PNG_INCLUDE_DIRS}
                                  ${ImageMagick_INCLUDE_DIRS})
ENDIF()

# ---- 3rd party include directories ----
INCLUDE_DIRECTORIES(${IPP_INCLUDE_DIRS}
                    ${MKL_INCLUDE_DIRS}
                    ${OPENCL_INCLUDE_DIRS}
                    ${EIGEN3_INCLUDE_DIRS}
                    ${OpenCV_INCLUDE_DIRS}
                    ${MESASR_INCLUDE_DIRS}
                    ${LIBAV_INCLUDE_DIRS}
                    ${LIBDC_INCLUDE_DIRS}
                    ${V4L_INCLUDE_DIRS}
                    ${XINE_INCLUDE_DIRS}
                    ${OPENGL_INCLUDE_DIR}
                    ${GLEW_INCLUDE_DIRS}
                    ${LIBFREENECT_INCLUDE_DIRS}
                    ${LIBFREENECT2_INCLUDE_DIRS}
                    ${PYLON_INCLUDE_DIRS}
                    ${PCL_INCLUDE_DIRS}
                    ${OPENNI_INCLUDE_DIRS}
                    ${RSB_INCLUDE_DIRS}
                    ${RSC_INCLUDE_DIRS}
                    ${BOOST_INCLUDE_DIR}
                    ${PROTOBUF_INCLUDE_DIRS}
                    ${ZMQ_INCLUDE_DIRS}
                    ${LIBUSB_INCLUDE_DIRS}
                    ${Qt5Widgets_INCLUDE_DIRS}
                    ${Qt5OpenGL_INCLUDE_DIRS}
                    ${BULLET_INCLUDE_DIRS}
                    ${RST_INCLUDE_DIRS}
                    ${XIAPI_INCLUDE_DIRS}
                    ${LIBIRIMAGER_INCLUDE_DIRS})

# ---- Variables for 3rd party libraries ----
LIST(REMOVE_DUPLICATES REQUIRED_LIBRARIES_LIST)

LIST(APPEND ICLUtils_3RDPARTY_LIBRARIES ${REQUIRED_LIBRARIES_LIST})
LIST(APPEND ICLUtils_3RDPARTY_LIBRARIES ${IPP_LIBRARIES})
LIST(APPEND ICLUtils_3RDPARTY_LIBRARIES ${OPENCL_LIBRARIES})
LIST(APPEND ICLUtils_3RDPARTY_LIBRARIES ${DL_LIBRARIES})

LIST(APPEND ICLMath_3RDPARTY_LIBRARIES ${MKL_LIBRARIES})

LIST(APPEND ICLCore_3RDPARTY_LIBRARIES ${OpenCV_LIBRARIES})

LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${MESASR_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBAV_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${ImageMagick_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBDC_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${V4L_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${XINE_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBUSB_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${OPENGL_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${XIAPI_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBIRIMAGER_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBUDEV_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBFREENECT_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${LIBFREENECT2_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${PYLON_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${OPENNI_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${RSB_RSC_AND_PROTOBUF_LIBRARIES_PC})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${RSC_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${RST_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${BOOST_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${ZMQ_LIBRARIES})
LIST(APPEND ICLIO_3RDPARTY_LIBRARIES ${Qt5_LIBRARIES})


LIST(APPEND ICLQt_3RDPARTY_LIBRARIES ${GLEW_LIBRARIES})
LIST(APPEND ICLQt_3RDPARTY_LIBRARIES ${Qt5_LIBRARIES})

LIST(APPEND ICLGeom_3RDPARTY_LIBRARIES ${PCL_LIBRARIES_PC})
LIST(APPEND ICLGeom_3RDPARTY_LIBRARIES ${RSB_RSC_AND_PROTOBUF_LIBRARIES_PC})
LIST(APPEND ICLGeom_3RDPARTY_LIBRARIES ${RST_LIBRARIES})

LIST(APPEND ICLPhysics_3RDPARTY_LIBRARIES ${BULLET_LIBRARIES})

#---- Add src sub directories ----
IF(WIN32)
  ADD_SUBDIRECTORY(3rdparty)
ENDIF()
ADD_SUBDIRECTORY(ICLUtils)
ADD_SUBDIRECTORY(ICLMath)
ADD_SUBDIRECTORY(ICLCore)
ADD_SUBDIRECTORY(ICLFilter)
ADD_SUBDIRECTORY(ICLIO)
ADD_SUBDIRECTORY(ICLCV)
IF(QT4_FOUND)
  ADD_SUBDIRECTORY(ICLQt)
ENDIF()
ADD_SUBDIRECTORY(ICLGeom)
ADD_SUBDIRECTORY(ICLMarkers)
IF(BULLET_FOUND)
  ADD_SUBDIRECTORY(ICLPhysics)
ENDIF()

#---- Add documentation ----
ADD_SUBDIRECTORY(doc)

#---- Add cmake modules ----
ADD_SUBDIRECTORY(cmake)

# ---- pkgconfig file ----
# GET_PROPERTY(ALL_INLUDE_DIRS DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
# GET_PROPERTY(ALL_LIBS DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY CMAKE_STANDARD_LIBRARIES)
# message(STATUS "Jihaaaaaaaaaaaaaaaaaaaaaa: ${ALL_INCLUDE_DIRS}")
# message(STATUS "Jihaaaaaaaaaaaaaaaaaaaaaa: ${ALL_LIBS}")

# LIST(REMOVE_DUPLICATES ALL_INCLUDE_DIRS)
# STRING(REPLACE ";" " -I" # first -I is in icl.pc.in
#        ICL_INCLUDES_BLANK
#        "${ALL_INCLUDE_DIRS}")

# STRING(REPLACE ";" " "
#        ICL_DEFINITIONS_BLANK
#        "${ICL_DEFINITIONS}")
# CONFIGURE_FILE(icl.pc.in icl.pc @ONLY)
# MESSAGE(STATUS "Package-config file will be installed to lib/pkgconfig/${ICL_NAME}-${SO_VERSION}.pc")
# INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/icl.pc
#         DESTINATION lib/pkgconfig
#         RENAME      "${PKG_CONFIG_FILE_NAME}")

# ---- icl-make, icl-version and icl-install-project ----
SET(PKG_CONFIG_FILE_NAME_NO_PC "ICL-${SO_VERSION}")

INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/src/ICLUtils/ICLConfig.h
        DESTINATION include/${INSTALL_PATH_PREFIX}/ICLUtils)

IF(NOT WIN32)
  FOREACH(FILE icl-make icl-create-project icl-create-cmake-project icl-version)
    SET(SRC scripts/${FILE}.in)
    SET(DST ${CMAKE_CURRENT_BINARY_DIR}/scripts/${FILE})
    CONFIGURE_FILE(${SRC} ${DST} @ONLY)
    INSTALL(FILES ${DST}
            PERMISSIONS OWNER_WRITE OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
            DESTINATION bin/)
  ENDFOREACH()
ENDIF()




FILE(COPY scripts/icl-create-video.sh DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/scripts)
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/scripts/icl-create-video.sh
        PERMISSIONS OWNER_WRITE OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
        DESTINATION bin/)

CONFIGURE_FILE(scripts/icl-create-project-data/Makefile.custom.in
               ${CMAKE_CURRENT_BINARY_DIR}/scripts/icl-create-project-data/Makefile.custom @ONLY)
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/scripts/icl-create-project-data/Makefile.custom
        DESTINATION ${RESOURCE_DIR}/ RENAME Makefile.custom.template)

FOREACH(FILE Makefile doxyfile sample-test.cpp)
  SET(SRC scripts/icl-create-project-data/${FILE})
  SET(DST ${CMAKE_CURRENT_BINARY_DIR}/scripts/icl-create-project-data)
  FILE(COPY ${SRC} DESTINATION ${DST})
  INSTALL(FILES ${DST}/${FILE} DESTINATION ${RESOURCE_DIR} RENAME ${FILE}.template)
ENDFOREACH()

FOREACH(FILE app.CMakeLists.txt CMakeLists.txt latex.clear.sh 
             latex.report.plots.sizevarplot.tex latex.talk.talk.tex 
             src.HelloWorld.cpp app.main.cpp Doxyfile.in latex.library.bib 
             latex.report.report.tex LICENSE.LGPL  src.HelloWorld.h 
             latex.build.sh latex.quick.sh 
             latex.report.sections.introduction.tex src.CMakeLists.txt)
  SET(SRC scripts/icl-create-cmake-project-data/${FILE})
  SET(DST ${CMAKE_CURRENT_BINARY_DIR}/scripts/icl-create-cmake-project-data)
  FILE(COPY ${SRC} DESTINATION ${DST})
  INSTALL(FILES ${DST}/${FILE} DESTINATION ${RESOURCE_DIR} RENAME ${FILE}.template)
ENDFOREACH()

# ---- PKG-config ----
IF(BULLET_FOUND)
  CREATE_PKGCONFIG(NAME ICL PKGCONFIG_DEPS ICLPhysics-${SO_VERSION} ICLMarkers-${SO_VERSION})
ELSE()
  CREATE_PKGCONFIG(NAME ICL PKGCONFIG_DEPS ICLMarkers-${SO_VERSION} )
ENDIF()