cmake_minimum_required(VERSION 2.8)
set(project_DIR "/share/imagedb/slmotion")

if(NOT CMAKE_BUILD_TYPE)
  #set(CMAKE_BUILD_TYPE "Release")
  set(CMAKE_BUILD_TYPE "Debug")
endif(NOT CMAKE_BUILD_TYPE)

cmake_policy(VERSION 2.4)
if(COMMAND cmake_policy)
  cmake_policy(SET CMP0003 NEW)
  cmake_policy(SET CMP0005 NEW)
  cmake_policy(SET CMP0007 NEW)
  cmake_policy(SET CMP0006 NEW)
endif(COMMAND cmake_policy)

project(SLMotion)

set(EXTERNAL_LIBS)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS")
if (APPLE)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -std=c++11") 
  set(CMAKE_SHARED_LINKER_FLAGS "-stdlib=libc++")
  set(CMAKE_EXE_LINKER_FLAGS "-stdlib=libc++")
  set(CMAKE_MODULE_LINKER_FLAGS "-stdlib=libc++")
else (APPLE)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") 
endif (APPLE)

set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -g")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O2")

find_package( ZLIB REQUIRED )

find_package(PythonLibs REQUIRED)
include_directories(${PYTHON_INCLUDE_PATH})

if (ENABLE_LIBFLANDMARK)
#  set(LIBFLANDMARK_DIR "${project_DIR}/libflandmark")
if (NOT APPLE)
  add_definitions(-DSLMOTION_LIBFLANDMARK_MODEL="${LIBFLANDMARK_DIR}/flandmark_model.dat")
endif (NOT APPLE)
  include_directories(${LIBFLANDMARK_DIR})
  link_directories(${LIBFLANDMARK_DIR})
  add_definitions(-DSLMOTION_ENABLE_LIBFLANDMARK)
  set(EXTERNAL_LIBS ${EXTERNAL_LIBS} flandmark)
endif (ENABLE_LIBFLANDMARK)

option(USE_CUSTOM_OPENCV "Use a custom-defined version of OpenCV" 0)
if(USE_CUSTOM_OPENCV)
  set(OpenCV_DIR "/share/imagedb/picsom/linux64/share/OpenCV")
  find_package(OpenCV REQUIRED)
  # fix libs variable
  set(OpenCV_LIBS opencv_core opencv_highgui opencv_nonfree opencv_objdetect 
    opencv_imgproc opencv_video opencv_flann opencv_features2d opencv_legacy 
    opencv_ml opencv_contrib)
  set(LIBFLANDMARK_DIR "${project_DIR}/libflandmark" CACHE STRING "libflandmark directory")
else (USE_CUSTOM_OPENCV)
  set(OpenCV_DIR)
  find_package(OpenCV REQUIRED)

  # fix libs variable
  set(OpenCV_LIBS opencv_core opencv_highgui opencv_nonfree opencv_objdetect 
    opencv_imgproc opencv_video opencv_flann opencv_features2d opencv_legacy 
    opencv_ml opencv_contrib)

  set(LIBFLANDMARK_DIR "${project_DIR}/libflandmark" CACHE STRING "libflandmark directory")
endif(USE_CUSTOM_OPENCV)

option(ENABLE_LIBFLANDMARK "Enable libflandmark support" 0)

file(GLOB SRCFILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
list(REMOVE_ITEM SRCFILES
  ${CMAKE_CURRENT_SOURCE_DIR}/slmotionmain.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/slrecognizermain.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/tests.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/tests_1.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/slconvertmain.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/skintest.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/testi.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/handconfigurationeditor.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/vidconvert.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/tritontest.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/slmotiongui.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/trainelm.cpp)
list(APPEND SRCFILES "${CMAKE_CURRENT_BINARY_DIR}/vcid.cpp")
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty)
list(APPEND SRCFILES "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/emd.c")

# link_directories(/home/luzardm1/intraface/lib)
# set (EXTERNAL_LIBS ${EXTERNAL_LIBS} intraface)

if (ENABLE_LIBLBFGS)
  list(APPEND SRCFILES "${CMAKE_CURRENT_SOURCE_DIR}/liblbfgs-1.10/lib/lbfgs.c")
endif (ENABLE_LIBLBFGS)

option(ENABLE_LIBHAND "Enable libhand support" 0)
if (ENABLE_LIBHAND)
  # FIND_PACKAGE(LibHand REQUIRED
  # PATHS "/share/imagedb/slmotion/libhand-0.9_opencv242/hand_cpp/dist"
  # NO_MODULE
  # NO_DEFAULT_PATH)
  # include_directories(${LibHand_INCLUDE_DIRS})
  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand)
  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader)
  # set(EXTERNAL_LIBS ${EXTERNAL_LIBS} ${LibHand_LIBRARIES})
  add_definitions(-DSLMOTION_ENABLE_LIBHAND)
  list(APPEND SRCFILES "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/hand_renderer.cc" 
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/hand_pose.cc" 
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/hand_camera_spec.cc" 
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/scene_spec.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/hog_utils.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/hog_cell_rectangles.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/printfstring.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/file_tools.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/dot_sceneloader.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/tinyxml/tinyxml.cpp"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/tinyxml/tinyxmlparser.cpp"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/tinyxml/tinystr.cpp"
    "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/tinyxml/tinyxmlerror.cpp")
  INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libhand/dot_sceneloader/tinyxml")
  # /usr/share/OGRE/cmake/modules/FindOGRE.cmake
  set(CMAKE_MODULE_PATH /usr/share/OGRE/cmake/modules ${CMAKE_MODULE_PATH})
  FIND_PACKAGE(OGRE REQUIRED)
  INCLUDE_DIRECTORIES(
    ${OGRE_INCLUDE_DIRS}
    ${OGRE_RenderSystem_GL_INCLUDE_DIR}
    ${OGRE_Plugin_BSPSceneManager_INCLUDE_DIR}
    ${OGRE_Plugin_OctreeSceneManager_INCLUDE_DIR}
    ${OGRE_Plugin_PCZSceneManager_INCLUDE_DIR}
    ${OGRE_Plugin_ParticleFX_INCLUDE_DIR}
  )
  set(EXTERNAL_LIBS ${OGRE_LIBRARIES} ${EXTERNAL_LIBS})
endif (ENABLE_LIBHAND)

# required for apple
option(USE_CUSTOM_BOOST "Use a custom version of boost instead of the
one supplied by the system by default" 0) 

set(CUSTOM_BOOST_DIR "" CACHE STRING "Sets the custom boost directory if a custom version of Boost is to be used.")

if (USE_CUSTOM_BOOST)
  set(Boost_DIR ${CUSTOM_BOOST_DIR})
  set(Boost_LIBRARIES boost_program_options boost_regex boost_unit_test_framework boost_python boost_filesystem boost_system)
  link_directories(${Boost_DIR}/lib)
  include_directories(${Boost_DIR}/include)
else (USE_CUSTOM_BOOST)
  find_package(Boost 1.36.0 REQUIRED COMPONENTS program_options regex unit_test_framework python filesystem system)
endif (USE_CUSTOM_BOOST)

#set(LIBUSB_DIR "" CACHE STRING "Directory where libusb is located.")

set(OPENNI_DIR "/share/imagedb/slmotion/OpenNI-Bin-Dev-Linux-x64-v1.5.2.23" CACHE STRING "Directory where OpenNI is located.")

set(OPENNI_INSTALL_DIR "/share/imagedb/slmotion/openni" CACHE STRING "Directory where OpenNI is installed.")
set(OPENNI_MODULES_DIR ${OPENNI_INSTALL_DIR} CACHE STRING "Directory where var/lib/ni/modules.xml may be found")

option(ENABLE_RUBNER_EMD "Compile with code dependent on Rubner's EMD implementation" 0)
option(ENABLE_PELE_FASTEMD "Compile with code dependent on Pele's FastEMD implementation" 0)
if (ENABLE_RUBNER_EMD)
  add_definitions(-DSLMOTION_WITH_RUBNER_EMD)
endif (ENABLE_RUBNER_EMD)
if (ENABLE_PELE_FASTEMD)
  add_definitions(-DSLMOTION_WITH_PELE_FASTEMD)
endif (ENABLE_PELE_FASTEMD)

option(ENABLE_OPENNI "Enable OpenNI support" 0)
if (ENABLE_OPENNI)
  include_directories(${OPENNI_DIR}/Include)
  link_directories(${OPENNI_INSTALL_DIR}/usr/lib)
  add_definitions(-DSLMOTION_ENABLE_OPENNI)
  add_definitions(-DSLMOTION_OPENNI_INSTALL_PATH="${OPENNI_MODULES_DIR}")
  set(EXTERNAL_LIBS ${EXTERNAL_LIBS} OpenNI)
endif (ENABLE_OPENNI)

find_package(LibXml2)

if (APPLE)
  # set(EXTERNAL_LIBS ${EXTERNAL_LIBS} Accelerate)
  FIND_LIBRARY(ACCELERATE_LIBRARY Accelerate)
  set(EXTERNAL_LIBS ${EXTERNAL_LIBS} ${ACCELERATE_LIBRARY})
else (APPLE)
    enable_language(Fortran)
    find_package(BLAS)
    find_package(LAPACK)
    set(EXTERNAL_LIBS ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES} ${EXTERNAL_LIBS})
endif (APPLE)

# if (APPLE)
#   set(EXTERNAL_LIBRARIES ${EXTERNAL_LIBRARIES} avcodec avformat avfilter avutil swscale)
# else (APPLE)
#   set(CMAKE_MODULE_PATH "/usr/share/kde4/apps/cmake/modules/")
#   #find_package(FFmpeg)
# endif (APPLE)
# if (FFMPEG_FOUND)
#   add_definitions(-DSLMOTION_ENABLE_FFMPEG)
# endif (FFMPEG_FOUND)

#find_package(PkgConfig)
#pkg_check_modules(SWScale REQUIRED libswscale)

find_package(Doxygen)
if (DOXYGEN_FOUND)
  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
  add_custom_target(doc ${DOXYGEN_EXECUTABLE} 
    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    )
endif(DOXYGEN_FOUND)

include_directories(${LIBXML2_INCLUDE_DIR})

# find_package(wxWidgets COMPONENTS core base REQUIRED)
# include( "${wxWidgets_USE_FILE}" )

# if(APPLE)
#   set(ENV{PKG_CONFIG_PATH} /opt/X11/lib/pkgconfig/:$ENV{PKG_CONFIG_PATH})
#  set(EXTERNAL_LIBS -L/usr/local/opt/gettext/lib ${EXTERNAL_LIBS})
#  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/local/opt/gettext/include")
#endif(APPLE)

option(ENABLE_GTK "Enable GTK gui" 0)
option(ENABLE_QT "Enable Qt gui" 0)

if (ENABLE_GTK)
  find_package(PkgConfig REQUIRED)
  pkg_check_modules(GTK2 REQUIRED gtk+-2.0)
  include_directories(${GTK2_INCLUDE_DIRS})
  link_directories(${GTK2_LINK_DIRS})
  set(EXTERNAL_LIBS ${GTK2_LIBRARIES} ${EXTERNAL_LIBS})
  add_definitions(-DSLMOTION_WITH_GTK)
endif(ENABLE_GTK)

if (ENABLE_QT)
  find_package(Qt4 REQUIRED)
  include(${QT_USE_FILE}) # sets up include directories etc.
  set(EXTERNAL_LIBS ${QT_LIBRARIES} ${EXTERNAL_LIBS})
  add_definitions(-DSLMOTION_WITH_QT)
  set(Qt_HEADERS MainWindow.hpp ConfigurationWindow.hpp)
  QT4_WRAP_CPP(Qt_HEADERS_MOC MainWindow.hpp ${Qt_HEADERS})
endif(ENABLE_QT)

option(ENABLE_LIBLBFGS "Enable liblbfgs" 0)
if (ENABLE_LIBLBFGS)
  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/liblbfgs-1.10/include)
  add_definitions(-DSLMOTION_WITH_LIBLBFGS)
endif(ENABLE_LIBLBFGS)


option(ENABLE_LIBSVM "Enable libsvm" 0)
if (ENABLE_LIBSVM)
  add_definitions(-DSLMOTION_WITH_LIBSVM)
endif(ENABLE_LIBSVM)

set(INTRAFACE_INSTALL_DIR "/share/imagedb/slmotion/intraface" CACHE PATH "Directory where intraface is located.")
option(ENABLE_INTRAFACE "Enable intraface support" 0)
if (ENABLE_INTRAFACE)
  include_directories(${INTRAFACE_INSTALL_DIR}/include)
  link_directories(${INTRAFACE_INSTALL_DIR}/lib)
  add_definitions(-DSLMOTION_INTRAFACE_PREFIX="${INTRAFACE_INSTALL_DIR}")
  add_definitions(-DSLMOTION_WITH_INTRAFACE)
  set (EXTERNAL_LIBS ${EXTERNAL_LIBS} intraface)
  list(APPEND SRCFILES "${INTRAFACE_INSTALL_DIR}/src/binary_model_file.cpp")
endif (ENABLE_INTRAFACE)

set(EXTERNAL_LIBS ${EXTERNAL_LIBS} ${ZLIB_LIBRARIES} ${OpenCV_LIBS} ${LIBXML2_LIBRARIES} ${Boost_LIBRARIES} ${FFMPEG_LIBRARIES} ${SWScale_LIBRARIES} ${PYTHON_LIBRARIES})

option(MAKE_DYNAMIC_LIBRARY "Create a dynamic library instead of linking object files directly" 1)
if(MAKE_DYNAMIC_LIBRARY)
  add_library(slmotion SHARED ${SRCFILES} ${Qt_HEADERS_MOC})
  if (APPLE)
    target_link_libraries(slmotion ${EXTERNAL_LIBS})
  endif(APPLE)
  set(EXTERNAL_LIBS slmotion ${EXTERNAL_LIBS})
endif(MAKE_DYNAMIC_LIBRARY)

SET(TEST_DATA_DIRECTORY "/share/imagedb/slmotion/tests" CACHE STRING "Directory for unit test data" )
add_definitions(-DSLMOTION_TEST_DATA_DIRECTORY="${TEST_DATA_DIRECTORY}")

add_definitions(-DSLMOTION_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}")

option(VERBOSE_MAKEFILE "Create verbose makefile" 0)
if(VERBOSE_MAKEFILE)
  set(CMAKE_VERBOSE_MAKEFILE true)
endif(VERBOSE_MAKEFILE)

option(HELGRIND_ANNOTATIONS "Define Helgrind annotation macros to reduce log clutter from inlined libstdc++ functions" 0)
if (HELGRIND_ANNOTATIONS)
  add_definitions(-D_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE\\\(A\\\)=ANNOTATE_HAPPENS_BEFORE\\\(A\\\))
  add_definitions(-D_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER\\\(A\\\)=ANNOTATE_HAPPENS_AFTER\\\(A\\\))
endif(HELGRIND_ANNOTATIONS)

option(DISABLE_GUI "Disable GUI" 0)
if(DISABLE_GUI)
  add_definitions(-DSLMOTION_DISABLE_GUI)
endif(DISABLE_GUI)

set(LIBVIDREADER_DIR "${project_DIR}/vid_reader" CACHE STRING "libvidreader directory")
option(ENABLE_VIDFILE "Enable lossless .vid file support" 0)
if(ENABLE_VIDFILE)
  add_definitions(-DSLMOTION_ENABLE_VIDFILE_SUPPORT)
  link_directories(${LIBVIDREADER_DIR})
  include_directories(${LIBVIDREADER_DIR})
  set(EXTERNAL_LIBS ${EXTERNAL_LIBS} vidreader)
endif(ENABLE_VIDFILE)

option(NOHIGHGUI "Should be enabled e.g. for Apple systems if OpenCV has been compiled without highgui support." 0)
if(NOHIGHGUI)
  add_definitions(-DNOHIGHGUI)
endif(NOHIGHGUI)

option(ENABLE_PICSOM "Enable PicSOM integration" 0)
if (ENABLE_PICSOM)
  set(USE_CUSTOM_OPENCV 1)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS")
  set(PICSOM_DIR $ENV{HOME}/picsom)
  set(PICSOMINCLUDE_DIR "${PICSOM_DIR}/c++" "${PICSOM_DIR}/segmentation")
  set(PICSOMLIB_DIR "${PICSOM_DIR}/c++/linux64/debug")
  set(PICSOMLINUX64LIB_DIR "/share/imagedb/picsom/linux64/lib")
  include_directories(${PICSOMINCLUDE_DIR} /usr/include/mysql)
  add_definitions(-DSLMOTION_ENABLE_PICSOM)
  link_directories(${PICSOMLIB_DIR})
  link_directories(${PICSOMLINUX64LIB_DIR})
  set(EXTERNAL_LIBS ${EXTERNAL_LIBS} picsom rt magic mad fftw3 audiofile sndfile pthread sqlite3 mysqlclient jaula csoap-1.1 nanohttp-1.1 vl gcrypt ssl aspell caffe leveldb protobuf glog)
#  add_library(picsom SHARED ${PICSOM_OBJECT_FILES})
#  SET_TARGET_PROPERTIES(picsom PROPERTIES LINKER_LANGUAGE CXX)
endif(ENABLE_PICSOM)

# if (ENABLE_PICSOM OR ENABLE_VIDFILE)
#   set(EXTERNAL_LIBS ${EXTERNAL_LIBS} z)
# endif(ENABLE_PICSOM OR ENABLE_VIDFILE)

option(THREADING "Enable multiple threads" 0)
if(THREADING)
  add_definitions(-DSLMOTION_THREADING)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lpthread")
endif(THREADING)

option(BOOST_REGEX "Enable Boost Regex library instead of std::regex (the implementation of which is incomplete as of GCC 4.5.1)" 1)
if (BOOST_REGEX)
  add_definitions(-DSLMOTION_BOOST_REGEX)
endif(BOOST_REGEX)

option(MAKE_SLMOTION "Make the main executable" 1)
option(MAKE_SLMOTION_GUI "Make the graphical frontend" 1)
option(MAKE_TRAINELM "Make the ELM trainer" 0)
option(MAKE_SLRECOGNIZER "Make SLRecognizer executable" 0)
option(MAKE_SLCONVERT "Make SLConvert executable" 0)
option(MAKE_TESTS "Make unit test executable" 1)
option(MAKE_TESTI "Make the funny test program" 0)
option(MAKE_HANDCONFIGURATIONEDITOR "Make the nice hand configuration editor app" 0)
option(MAKE_VIDCONVERT "Make the nice vid file converter" 0)
option(MAKE_ONI2PNG "Make the nice oni to png converter" 0)

add_custom_target(slmotion_PREBUILD)
# add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/vcid.cpp" 
#  COMMAND python "${CMAKE_CURRENT_SOURCE_DIR}/createid.py" \\* > "${CMAKE_CURRENT_BINARY_DIR}/vcid.cpp")
add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/vcid.cpp" 
  COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/createvcid.sh > "${CMAKE_CURRENT_BINARY_DIR}/vcid.cpp")

set(COMMON_OBJECT_FILES ${PICSOM_OBJECT_FILES})
if(NOT MAKE_DYNAMIC_LIBRARY)
  set(COMMON_OBJECT_FILES ${COMMON_OBJECT_FILES} ${SRCFILES})
endif(NOT MAKE_DYNAMIC_LIBRARY)

#set(lib_dest_dir lib)
#set(bin_dest_dir bin)
#set(shared_dest_dir share)
#if(APPLE)
#  set(MACOSX_BUNDLE_BUNDLE_NAME slmotion)
#  set(lib_dest_dir slmotion.app/Contents/MacOS)
#  set(bin_dest_dir slmotion.app/Contents/MacOS)
#endif(APPLE)
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX/lib}")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
set(CMAKE_INSTALL_NAME_DIR @executable_path)

if(MAKE_SLMOTION)
#    add_executable(slmotion_main MACOSX_BUNDLE slmotionmain.cpp)
    add_executable(slmotion_main slmotionmain.cpp)
    set_target_properties(slmotion_main PROPERTIES OUTPUT_NAME slmotion)
    # set_target_properties(slmotion_main PROPERTIES MACOSX_BUNDLE TRUE)
    target_link_libraries(slmotion_main ${EXTERNAL_LIBS})
    set_property(TARGET slmotion_main PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
    set_property(TARGET slmotion_main PROPERTY INSTALL_RPATH 
      ${CMAKE_INSTALL_PREFIX}/lib)
endif(MAKE_SLMOTION)

if(MAKE_SLMOTION_GUI)
  add_executable(slmotiongui slmotiongui.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(slmotiongui ${EXTERNAL_LIBS})
endif(MAKE_SLMOTION_GUI)

if(MAKE_TRAINELM)
  add_executable(trainelm trainelm.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(trainelm ${EXTERNAL_LIBS})
endif(MAKE_TRAINELM)

if(MAKE_SLRECOGNIZER)
  add_executable(slrecognizer slrecognizermain.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(slrecognizer ${EXTERNAL_LIBS})
endif(MAKE_SLRECOGNIZER)

if(MAKE_SLCONVERT)
  add_executable(slconvert slconvertmain.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(slconvert ${EXTERNAL_LIBS})
endif(MAKE_SLCONVERT)

if(MAKE_TESTS)
  add_executable(tests tests.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(tests ${EXTERNAL_LIBS})
endif(MAKE_TESTS)

if(MAKE_TESTI)
  add_executable(testi testi.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(testi ${EXTERNAL_LIBS})
endif(MAKE_TESTI)

if(MAKE_HANDCONFIGURATIONEDITOR)
  add_executable(handconfigurationeditor handconfigurationeditor.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(handconfigurationeditor ${EXTERNAL_LIBS})
endif(MAKE_HANDCONFIGURATIONEDITOR)

if(MAKE_VIDCONVERT)
  add_executable(vidconvert vidconvert.cpp ${COMMON_OBJECT_FILES})
  target_link_libraries(vidconvert ${EXTERNAL_LIBS})
endif(MAKE_VIDCONVERT)

if(MAKE_ONI2PNG)
  add_executable(oni2png oni2png.cpp)
  target_link_libraries(oni2png ${EXTERNAL_LIBS})
endif(MAKE_ONI2PNG)

#install(TARGETS slmotion_main BUNDLE DESTINATION . RUNTIME DESTINATION bin) 
#install(TARGETS slmotion BUNDLE DESTINATION . LIBRARY DESTINATION lib)
install(TARGETS slmotion_main slmotion RUNTIME DESTINATION bin LIBRARY DESTINATION lib)

if (MAKE_SLMOTION_GUI)
  install(TARGETS slmotiongui RUNTIME DESTINATION bin)
endif (MAKE_SLMOTION_GUI)

if (MAKE_TRAINELM)
  install(TARGETS trainelm RUNTIME DESTINATION bin)
endif (MAKE_TRAINELM)

if (MAKE_TESTS)
  install(TARGETS tests RUNTIME DESTINATION bin)
endif (MAKE_TESTS)

if (MAKE_TESTI)
  install(TARGETS testi RUNTIME DESTINATION bin)
endif (MAKE_TESTI)

if (MAKE_HANDCONFIGURATIONEDITOR)
  install(TARGETS handconfigurationeditor RUNTIME DESTINATION bin)
endif (MAKE_HANDCONFIGURATIONEDITOR)

install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/annotationtemplate.xsd"
  "${CMAKE_CURRENT_SOURCE_DIR}/haarcascade_frontalface_alt.xml"
  "${CMAKE_CURRENT_SOURCE_DIR}/feature.xsd"
  "${CMAKE_CURRENT_SOURCE_DIR}/default.ann"
  "${CMAKE_CURRENT_SOURCE_DIR}/EAFv2.6.xsd"
  "${CMAKE_CURRENT_SOURCE_DIR}/PythonExampleComponent.py"
  "${CMAKE_CURRENT_SOURCE_DIR}/ogre_plugins.cfg"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/scene_spec.yml"
  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/slmotion")
if (ENABLE_LIBFLANDMARK)
  install(FILES "${LIBFLANDMARK_DIR}/flandmark_model.dat" 
    DESTINATION "${CMAKE_INSTALL_PREFIX}/share/flandmark")
endif (ENABLE_LIBFLANDMARK)

install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/blackness.material"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/hand_model_license.txt"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/hand.skeleton"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/skin.material"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/hand.mesh"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/hand.scene"
  "${CMAKE_CURRENT_SOURCE_DIR}/hand_model/ogre/hand_texture.png"
  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/slmotion/ogre")
install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/hpe_pitch.model"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/hpe_yaw.model"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_eyebrow.eig"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_eye.eig"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_vmouth.eig"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_hmouth.eig"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_eye_nb.model"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_eyebrow_nb.model"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_vmouth_nb.model"
  "${CMAKE_CURRENT_SOURCE_DIR}/nm_model/sfe_hmouth_nb.model"
  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/slmotion/models")

#if (APPLE)
#  install(FILES "${Boost_DIR}/lib/libboost_program_options.dylib" 
#    "${Boost_DIR}/lib/libboost_regex.dylib"
#    "${Boost_DIR}/lib/libboost_unit_test_framework.dylib"
#    "${Boost_DIR}/lib/libboost_python.dylib"
#    DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
#  if (EXISTS "${OPENNI_INSTALL_DIR}/usr/lib/libOpenNI.dylib")
#   install(FILES
#    "${OPENNI_INSTALL_DIR}/usr/lib/libOpenNI.dylib"
#    "${OPENNI_INSTALL_DIR}/usr/lib/libnimCodecs.dylib"
#    "${OPENNI_INSTALL_DIR}/usr/lib/libnimRecorder.dylib"
#    "${OPENNI_INSTALL_DIR}/usr/lib/libnimMockNodes.dylib"
#    "${LIBUSB_DIR}/lib/libusb-1.0.0.dylib"
#    DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
# endif(EXISTS "${OPENNI_INSTALL_DIR}/usr/lib/libOpenNI.dylib") 
#endif (APPLE)

# use, i.e. don't skip the full RPATH for the build tree
# SET(CMAKE_SKIP_BUILD_RPATH  FALSE)

# when building, don't use the install RPATH already
# (but later on when installing)
# SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 

# SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
#SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
#set_property(TARGET slmotion PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
set_property(TARGET tests PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
set_property(TARGET tests PROPERTY INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)

if (MAKE_TESTI)
  set_property(TARGET testi PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
  set_property(TARGET testi PROPERTY INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
endif (MAKE_TESTI)

if (MAKE_HANDCONFIGURATIONEDITOR)
  set_property(TARGET handconfigurationeditor PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
  set_property(TARGET handconfigurationeditor PROPERTY INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
endif (MAKE_HANDCONFIGURATIONEDITOR)

if (MAKE_SLMOTION_GUI)
  set_property(TARGET slmotiongui PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
  set_property(TARGET slmotiongui PROPERTY INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
endif(MAKE_SLMOTION_GUI)

if(MAKE_TRAINELM)
  set_property(TARGET trainelm PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
  set_property(TARGET trainelm PROPERTY INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
endif(MAKE_TRAINELM)


# the RPATH to be used when installing, but only if it's not a system directory
#LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
#IF("${isSystemDir}" STREQUAL "-1")
#   SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
#ENDIF("${isSystemDir}" STREQUAL "-1")

if (APPLE)
  install(CODE "execute_process(COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/fix_rpath_osx.sh ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_INSTALL_PREFIX})")
endif (APPLE)

install(CODE "execute_process(COMMAND ${CMAKE_INSTALL_PREFIX}/bin/slmotion --generate-default-config OUTPUT_FILE \"${CMAKE_INSTALL_PREFIX}/share/slmotion/default.conf\")")
