# ----------------------------------------------------------------------------
# Root CMake file for the MRPT libraries and applications
#
#  Run with "cmake ." at the root directory to build the makefiles for
#   the MRPT C++ library, the samples, and the applications. Some scripts
#   for generating the documentation, etc... are also updated.
#
#  For compiling instructions for all compilers and platforms, see 
#   http://www.mrpt.org/Building_and_Installing_Instructions
#
#  2007-2010, Jose Luis Blanco <jlblanco@ctima.uma.es>
#
#  NOTE: CMake can be obtained at http://www.cmake.org/
# ----------------------------------------------------------------------------

PROJECT(MRPT)
if(MSVC)
	CMAKE_MINIMUM_REQUIRED(VERSION 2.6.4)
else(MSVC)
	CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
endif(MSVC)

# --------------------------------------------------------------
# Indicate CMake 2.7 and above that we don't want to mix relative
#  and absolute paths in linker lib lists.
# Run "cmake --help-policy CMP0003" for more information.
# --------------------------------------------------------------
if(COMMAND cmake_policy)
      cmake_policy(SET CMP0003 NEW)
endif(COMMAND cmake_policy)

# ----------------------------------------------------------------------------
#  Loads the current version number:
# ----------------------------------------------------------------------------
FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/version_prefix.txt" CMAKE_MRPT_VERSION_NUMBER)

# For example: "0.5.1"
STRING(REGEX MATCHALL "[0-9]+" CMAKE_MRPT_VERSION_PARTS "${CMAKE_MRPT_VERSION_NUMBER}")

LIST(GET CMAKE_MRPT_VERSION_PARTS 0 CMAKE_MRPT_VERSION_NUMBER_MAJOR)
LIST(GET CMAKE_MRPT_VERSION_PARTS 1 CMAKE_MRPT_VERSION_NUMBER_MINOR)
LIST(GET CMAKE_MRPT_VERSION_PARTS 2 CMAKE_MRPT_VERSION_NUMBER_PATCH)
SET(CMAKE_MRPT_FULL_VERSION "${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH}")

IF(WIN32)
	SET(MRPT_DLL_VERSION_POSTFIX "${CMAKE_MRPT_VERSION_NUMBER_MAJOR}${CMAKE_MRPT_VERSION_NUMBER_MINOR}${CMAKE_MRPT_VERSION_NUMBER_PATCH}")
ELSE(WIN32)
	SET(MRPT_DLL_VERSION_POSTFIX "")
ENDIF(WIN32)

# ----------------------------------------------------------------------------
# The root directory for all MRPT libraries/modules:
# ----------------------------------------------------------------------------
SET(MRPT_LIBS_ROOT "${CMAKE_SOURCE_DIR}/libs" CACHE INTERNAL "")  # This emulates global vars

LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmakemodules")

# Useful macros:
INCLUDE(cmakemodules/UtilsMacros.cmake REQUIRED)


# ----------------------------------------------------------------------------
#  Autodetect if we are in a SVN repository
# ----------------------------------------------------------------------------
FIND_PROGRAM(SVNVERSION_PATH svnversion)
MARK_AS_ADVANCED(force SVNVERSION_PATH)
IF(SVNVERSION_PATH)
	MESSAGE(STATUS "Extracting svn version, please wait...")
	execute_process(COMMAND ${SVNVERSION_PATH} -n ${MRPT_SOURCE_DIR} OUTPUT_VARIABLE SVNVERSION_RESULT)

	IF(SVNVERSION_RESULT MATCHES "exported")
		# This is NOT a svn repository:
		SET(CMAKE_MRPT_SVNVERSION "")
	ELSE(SVNVERSION_RESULT MATCHES "exported")
		SET(CMAKE_MRPT_SVNVERSION " svn:${SVNVERSION_RESULT}")
	ENDIF(SVNVERSION_RESULT MATCHES "exported")

	MESSAGE(STATUS "SVNVERSION: ${CMAKE_MRPT_SVNVERSION}")
ELSE(SVNVERSION_PATH)
	# We don't have svnversion:
	SET(CMAKE_MRPT_SVNVERSION "")
ENDIF(SVNVERSION_PATH)

# ----------------------------------------------------------------------------
# Detect GNU version:
# ----------------------------------------------------------------------------
IF(CMAKE_COMPILER_IS_GNUCXX)
	execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version
		          OUTPUT_VARIABLE CMAKE_MRPT_GCC_VERSION_FULL
		          OUTPUT_STRIP_TRAILING_WHITESPACE)

	# Typical output in CMAKE_MRPT_GCC_VERSION_FULL: "c++ (whatever) 4.2.3 (...)"
	#  Look for the version number
	STRING(REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_MRPT_GCC_VERSION_FULL}")
	#MESSAGE(STATUS "match: ${CMAKE_GCC_REGEX_VERSION}")

	# Split the three parts:
	STRING(REGEX MATCHALL "[0-9]+" CMAKE_MRPT_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}")

	LIST(GET CMAKE_MRPT_GCC_VERSIONS 0 CMAKE_MRPT_GCC_VERSION_MAJOR)
	LIST(GET CMAKE_MRPT_GCC_VERSIONS 1 CMAKE_MRPT_GCC_VERSION_MINOR)

	SET(CMAKE_MRPT_GCC_VERSION ${CMAKE_MRPT_GCC_VERSION_MAJOR}${CMAKE_MRPT_GCC_VERSION_MINOR})
	MESSAGE(STATUS "Detected version of GNU GCC: ${CMAKE_MRPT_GCC_VERSION}")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)


# ----------------------------------------------------------------------------
# Include the "CPack" package generator
# ----------------------------------------------------------------------------
SET(CMAKE_INSTALL_DEBUG_LIBRARIES 1)
INCLUDE(InstallRequiredSystemLibraries)

SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The Mobile Robot Programming Toolkit (MRPT)")
SET(CPACK_PACKAGE_VENDOR "Jose Luis Blanco Claraco")
SET(CPACK_PACKAGE_CONTACT "Jose Luis Blanco Claraco <jlblanco@ctima.uma.es>")

SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.txt")
SET(CPACK_RESOURCE_FILE_WELCOME "${CMAKE_CURRENT_SOURCE_DIR}/README.txt")
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "MRPT is a set of C++ libraries and applications for mobile robot software development.")
FILE(READ ${CPACK_PACKAGE_DESCRIPTION_FILE} CPACK_DESCRIPTION_TEXT)

SET(CPACK_PACKAGE_VERSION_MAJOR "${CMAKE_MRPT_VERSION_NUMBER_MAJOR}")
SET(CPACK_PACKAGE_VERSION_MINOR "${CMAKE_MRPT_VERSION_NUMBER_MINOR}")
SET(CPACK_PACKAGE_VERSION_PATCH "${CMAKE_MRPT_VERSION_NUMBER_PATCH}")

SET(CPACK_DEBIAN_PACKAGE_VERSION "${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH}")
SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}\r\rThe Mobile Robot Programming Toolkit (MRPT) is an extensive, cross-platform, and open source C++ library aimed to help robotics researchers to design and implement algorithms (mainly) in the fields of Simultaneous Localization and Mapping (SLAM) and computer vision (e.g. MonoSLAM).\rThe library allows an easy interface to many common sensors like laser scanners or cameras, and defines a versatile rawlog file format, used to store data sets gathered by a robot for posterior processing. The MRPT's format for rawlogs is Bayesian filter-friendly: sequences of action-observations, in a generic form that allows 2D/3D(6D) movements and any number of (extensible) observations.\r\r MRPT website: http://mrpt.sourceforge.net\r")

SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")
SET(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.txt")

SET(CPACK_SOURCE_GENERATOR "TGZ")

SET(CPACK_PACKAGE_INSTALL_DIRECTORY "mrpt-${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH}")

IF(WIN32)
	# --------------------------------
	# Packages for Windows
	# --------------------------------
	SET(CPACK_SOURCE_IGNORE_FILES ".svn/;.*~;build;CMakeCache.txt;_CPack_Pakages/;CMakeFiles/;install/;Makefile;*.cmake")

	# There is a bug in NSI that does not handle full unix paths properly. Make
	# sure there is at least one set of four (4) backlasshes.
	SET(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}/share/pixmaps\\\\mrpt_icon.ico")
	SET(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}/share/pixmaps\\\\mrpt_icon.ico")
	SET(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/apps/wx-common\\\\mrpt_logo.png")

	SET(CPACK_NSIS_INSTALLED_ICON_NAME "${CMAKE_CURRENT_SOURCE_DIR}/share/pixmaps\\\\mrpt_icon.ico")

	SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\mrpt.sourceforge.net")
	SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\www.isa.uma.es\\\\jlblanco")
	SET(CPACK_NSIS_CONTACT "jlblanco@ctima.uma.es")
	
	# Add mrpt/bin dir to system PATH
	SET(CPACK_NSIS_MODIFY_PATH ON)

	# Install header and source files:
	# ---------------------------------------------
	INSTALL(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/libs/"
		DESTINATION libs
		PATTERN ".svn" EXCLUDE
		PATTERN "*~" EXCLUDE)

	INSTALL(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/apps/"
		DESTINATION apps
		PATTERN ".svn" EXCLUDE
		PATTERN "*~" EXCLUDE)
		
	INSTALL(FILES 
		cmake_uninstall.cmake.in
		CMakeLists.txt
		config_file_examples.txt
		configure
		COPYING
		DATASETS.txt
		INSTALL_COMPILE.html
		MRPTConfig.cmake.in
		NEWS.html
		README
		README.Debian
		README.txt
		version_prefix.txt
		version_prefix_README.txt
	DESTINATION .)
		
	SET(CPACK_PACKAGE_EXECUTABLES 
		"camera-calib;Camera calibration GUI;features-matching;Visual feature matching;GridmapNavSimul;Gridmap simulator;RawLogViewer;RawLog Viewer;ReactiveNavigationDemo;Reactive navigation demo;prrt-navigator-demo;PRRT robot navigator demo;SceneViewer3D;Scene Viewer 3D;2d-slam-demo;2D KF-SLAM Simulator;navlog-viewer;Viewer of navigation log files")
		
	IF (EXISTS "${MRPT_SOURCE_DIR}/apps/hmt-slam-gui")
		SET(CPACK_PACKAGE_EXECUTABLES "${CPACK_PACKAGE_EXECUTABLES};hmt-slam-gui;HMT-SLAM visual interface")
	ENDIF (EXISTS "${MRPT_SOURCE_DIR}/apps/hmt-slam-gui")
	
		
	SET(CPACK_NSIS_MENU_LINKS
	    "doc;Documentation directory;bin;Directory of executables (bin);doc/chm/libMRPT-@CMAKE_MRPT_VERSION_NUMBER_MAJOR@.@CMAKE_MRPT_VERSION_NUMBER_MINOR@.@CMAKE_MRPT_VERSION_NUMBER_PATCH@.chm;MRPT libraries reference (CHM);README.txt;Read me;http://www.mrpt.org/;Online help;doc/mrpt-book.pdf;The MRPT book (PDF)")
		
	# File types association:
	SET(CPACK_NSIS_DEFINES "
		!include registerExtension.nsh
		")
	
	SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS "
		\\\${registerExtension} \\\"$INSTDIR\\\\bin\\\\RawLogViewer.exe\\\" \\\".rawlog\\\" \\\"Robotic Dataset File\\\" 
		\\\${registerExtension} \\\"$INSTDIR\\\\bin\\\\SceneViewer3D.exe\\\" \\\".3Dscene\\\" \\\"Robotic 3D scene\\\" 
		")
	SET(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS "  
		\\\${unregisterExtension} \\\".rawlog\\\" \\\"Robotic Dataset File\\\" 
		\\\${unregisterExtension} \\\".3Dscene\\\" \\\"Robotic 3D scene\\\" 
		")

	SET(CPACK_NSIS_MODIFY_PATH OFF)  # don't show this dialog

ENDIF(WIN32)
IF(UNIX)
	# --------------------------------
	# Packages for linux
	# --------------------------------
   	SET(CPACK_OUTPUT_FILE_PATH "MRPT-${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH}-Linux-${CMAKE_SYSTEM_PROCESSOR}.deb")
	SET(CPACK_DEBIAN_PACKAGE_NAME "libmrpt")
	SET(CPACK_PACKAGING_INSTALL_PREFIX "/usr/local")
	SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libcv1,libglu1-mesa,libwxgtk2.8-0")

	SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}")

	SET(CPACK_SOURCE_IGNORE_FILES ".svn;CMakeFiles;CMakeCache.txt;CPack*;progress.make;install_manifest.txt;cmake_install.cmake;cmake_psdk.cmake$;Makefile;.swp$;.*~;tags;cmake_uninstall.cmake$")

	SET(CPACK_GENERATOR DEB)

ENDIF(UNIX)

IF(APPLE)
	SET(CPACK_GENERATOR "TGZ;TBZ2;OSXX11")
Endif(APPLE)

INCLUDE(CPack)

# ------------------------------------------
# The debug post-fix of .dll /.so libs
# ------------------------------------------
set(CMAKE_DEBUG_POSTFIX  "-dbg")
# Libs are: "libmrpt-xxx"
#            ---
IF(MSVC)	
	set(MRPT_LIB_PREFIX "lib")
ENDIF(MSVC)

# In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
if (${CMAKE_GENERATOR} MATCHES ".*Makefiles")
    if("${CMAKE_BUILD_TYPE}" STREQUAL "")
        set(CMAKE_BUILD_TYPE Release)
    endif()
endif()


# ----------------------------------------------------------------------------
# 		CHECK FOR SYSTEM LIBRARIES, OPTIONS, ETC..
# ----------------------------------------------------------------------------

# Build (or not) some apps:
# ===================================================
SET(BUILD_MONOSLAM OFF CACHE BOOL "Build library mrpt-monoslam")
SET(BUILD_STEREOSLAM OFF CACHE BOOL "Build library mrpt-stereoslam")
SET(BUILD_APPs_GUIs ON CACHE BOOL "Build GUI applications: SceneViewer, RawLogViewer, ReactiveNavigationDemo.")
SET(BUILD_APPs_SLAM ON CACHE BOOL "Build applications XXX-SLAM")
SET(BUILD_APPs_SIMUL ON CACHE BOOL "Build applications simul-XXX and GridmapNavSimul")

MARK_AS_ADVANCED(BUILD_MONOSLAM)
MARK_AS_ADVANCED(BUILD_STEREOSLAM )
MARK_AS_ADVANCED(BUILD_APPs_GUIs)
MARK_AS_ADVANCED(BUILD_APPs_SLAM)
MARK_AS_ADVANCED(BUILD_APPs_SIMUL)

# If some app is not in this package, do NOT build it:
# =====================================================
IF (NOT EXISTS "${MRPT_SOURCE_DIR}/libs/monoslam/src")
	SET(BUILD_MONOSLAM OFF CACHE INTERNAL "" FORCE)
ENDIF (NOT EXISTS "${MRPT_SOURCE_DIR}/libs/monoslam/src")

IF (NOT EXISTS "${MRPT_SOURCE_DIR}/libs/stereoslam/src")
	SET(BUILD_STEREOSLAM OFF CACHE INTERNAL "" FORCE)
ENDIF (NOT EXISTS "${MRPT_SOURCE_DIR}/libs/stereoslam/src")


# Build static or dynamic libs?
# ===================================================
# Default: dynamic libraries:
SET(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)")
IF(BUILD_SHARED_LIBS)
	SET(CMAKE_MRPT_BUILD_SHARED_LIB "#define MRPT_BUILT_AS_DLL")
	SET(CMAKE_MRPT_BUILD_SHARED_LIB_ONOFF 1)
ELSE(BUILD_SHARED_LIBS)
	SET(CMAKE_MRPT_BUILD_SHARED_LIB "/* #define MRPT_BUILT_AS_DLL */")
	SET(CMAKE_MRPT_BUILD_SHARED_LIB_ONOFF 0)
ENDIF(BUILD_SHARED_LIBS)

# Only for Unix: use pkg-config to find libraries
# ===================================================
INCLUDE(FindPkgConfig OPTIONAL)
IF(PKG_CONFIG_FOUND)
	INCLUDE(FindPkgConfig)
ENDIF(PKG_CONFIG_FOUND)


# Build the ARIA library
# ===================================================
SET(BUILD_ARIA ON CACHE BOOL "Build an embedded version of ActivMedia ARIA library (interface to mobile robots)")
#MARK_AS_ADVANCED(BUILD_ARIA)
IF(BUILD_ARIA)
	SET(CMAKE_MRPT_HAS_ARIA 1)
ELSE(BUILD_ARIA)
	SET(CMAKE_MRPT_HAS_ARIA 0)
ENDIF(BUILD_ARIA)

# Build the xSENS library
# ===================================================
SET(BUILD_XSENS ON CACHE BOOL "Build an embedded version of xSens library (interface to xSens MTi device)")
#MARK_AS_ADVANCED(BUILD_XSENS)

IF(BUILD_XSENS)
	SET(CMAKE_MRPT_HAS_xSENS 1)
ELSE(BUILD_XSENS)
	SET(CMAKE_MRPT_HAS_xSENS 0)
ENDIF(BUILD_XSENS)

# Enable GCC profiling (GCC only)
# ===================================================
IF(CMAKE_COMPILER_IS_GNUCXX)
	SET(MRPT_ENABLE_PROFILING OFF CACHE BOOL "Enable profiling in the GCC compiler (Add flags: -g -pg)")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)

# Enable precompiled headers:
# ===================================================
SET(MRPT_ENABLE_PRECOMPILED_HDRS ON CACHE BOOL "Enable precompiled headers (thru 'mrpt/LIB.h')")
MARK_AS_ADVANCED(MRPT_ENABLE_PRECOMPILED_HDRS)


# MRPT_TRY_START/END blocks
# ===================================================
SET(MRPT_HAS_STACKED_EXCEPTIONS ON CACHE BOOL "Enable MRPT_TRY_START/END blocks (disable it for speed up).")

# MRPT embedded profiler is enabled only in Debug:
# ===================================================
SET(MRPT_ENABLE_EMBEDDED_GLOBAL_PROFILER OFF CACHE BOOL "Enable MRPT embedded profiler.")

# ASSERT_ blocks
# ===================================================
SET(MRPT_HAS_ASSERT ON CACHE BOOL "Enable ASSERT_ statements (disable it for speed up).")


# Enable libstdc++ parallel mode  (GCC only)
# ===================================================
IF(CMAKE_COMPILER_IS_GNUCXX)
	SET(MRPT_ENABLE_LIBSTD_PARALLEL_MODE OFF CACHE BOOL "Enable parallel mode in libstdc++ (requires GCC 4.2.2+)")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)


# Occupancy grid cellsize in bits: 8 or 16
# ===================================================
SET(MRPT_OCCUPANCY_GRID_CELLSIZE 8 CACHE STRING "Cell size for mrpt::slam::COccupancyGridMap2D (either 8 or 16 bits)")
IF(NOT MRPT_OCCUPANCY_GRID_CELLSIZE EQUAL 8 AND NOT MRPT_OCCUPANCY_GRID_CELLSIZE EQUAL 16)
	MESSAGE("MRPT_OCCUPANCY_GRID_CELLSIZE can have the values 8 or 16 only.")
ENDIF(NOT MRPT_OCCUPANCY_GRID_CELLSIZE EQUAL 8 AND NOT MRPT_OCCUPANCY_GRID_CELLSIZE EQUAL 16)


# Support for Bumblebee stereo camera:
# ===================================================
SET( MRPT_HAS_BUMBLEBEE OFF CACHE BOOL "Add support for Bumblebee Stereo Camera?")

IF(MRPT_HAS_BUMBLEBEE)
	SET( BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR "" CACHE PATH "Path to PGR FlyCapture library root directory")
	SET( BUMBLEBEE_TRICLOPS_ROOT_DIR "" CACHE PATH "Path to triclops library root directory")

	IF(UNIX)
		MESSAGE("Sorry! Bumblebee camera is supported only for Windows yet. Set MRPT_HAS_BUMBLEBEE to OFF")
		SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
	ELSE(UNIX)
		# Set to 1, next check for missing things and set to 0 on any error & report message:
		SET(CMAKE_MRPT_HAS_BUMBLEBEE 1)

		IF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR})
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR' does not exists. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR})

		IF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/include/PGRFlyCapture.h)
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR' does not contain include/PGRFlyCapture.h. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/include/PGRFlyCapture.h)

		IF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/lib/PGRFlyCapture.lib)
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR' does not contain lib/PGRFlyCapture.LIB. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/lib/PGRFlyCapture.lib)

		# ----

		IF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR})
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_TRICLOPS_ROOT_DIR' does not exists. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR})

		IF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR}/include/triclops.h)
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_TRICLOPS_ROOT_DIR' does not contain include/triclops.h. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR}/include/triclops.h)

		IF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR}/lib/triclops.lib)
			SET(CMAKE_MRPT_HAS_BUMBLEBEE 0)
			MESSAGE("The directory 'BUMBLEBEE_TRICLOPS_ROOT_DIR' does not contain lib/triclops.lib. Turn off BUMBLEBEE support or provide the correct path.")
		ENDIF(NOT EXISTS ${BUMBLEBEE_TRICLOPS_ROOT_DIR}/lib/triclops.lib)
	ENDIF(UNIX)

ENDIF(MRPT_HAS_BUMBLEBEE)


#   FabMap module for HMT-SLAM? (optional)
# =======================================
FIND_PACKAGE(FabMap QUIET)
IF(NOT FabMap_DIR)
	MARK_AS_ADVANCED(FabMap_DIR)
ENDIF(NOT FabMap_DIR)

IF(FabMap_FOUND)
	SET(CMAKE_MRPT_HAS_FABMAP  1)
ELSE(FabMap_FOUND)
	SET(CMAKE_MRPT_HAS_FABMAP  0)
ENDIF(FabMap_FOUND)


# Check for STXXL: (Not yet)
# =====================================
SET(CMAKE_MRPT_HAS_STXXL 0)

# Check for the FTDI headers (Linux only, in win32
#  we use built-in header & dynamic DLL load):
# ===================================================
IF(UNIX)
	FIND_FILE(FTDI_CONFIG_FILE libftdi-config)
	IF(FTDI_CONFIG_FILE)
		MARK_AS_ADVANCED(FTDI_CONFIG_FILE)

		SET(CMAKE_MRPT_HAS_FTDI 1)
		SET(CMAKE_MRPT_HAS_FTDI_SYSTEM 1)

		# Get the config params:
		EXECUTE_PROCESS(COMMAND ${FTDI_CONFIG_FILE} --libs
			RESULT_VARIABLE CMAKE_FTDI_CONFIG_RES
			OUTPUT_VARIABLE CMAKE_FTDI_LIBS
			OUTPUT_STRIP_TRAILING_WHITESPACE
			)
		IF(${CMAKE_FTDI_CONFIG_RES})
			MESSAGE("Error invoking FTDI config file:\n ${FTDI_CONFIG_FILE} --libs")
		ENDIF(${CMAKE_FTDI_CONFIG_RES})

		EXECUTE_PROCESS(COMMAND ${FTDI_CONFIG_FILE} --cflags
			RESULT_VARIABLE CMAKE_FTDI_CONFIG_RES
			OUTPUT_VARIABLE CMAKE_FTDI_CFLAGS
			OUTPUT_STRIP_TRAILING_WHITESPACE
			)
		IF(${CMAKE_FTDI_CONFIG_RES})
			MESSAGE("Error invoking FTDI config file:\n ${FTDI_CONFIG_FILE} --cflags")
		ENDIF(${CMAKE_FTDI_CONFIG_RES})

		ADD_DEFINITIONS(${CMAKE_FTDI_CFLAGS})

	ELSE(FTDI_CONFIG_FILE)
		SET(CMAKE_MRPT_HAS_FTDI 0)
	ENDIF(FTDI_CONFIG_FILE)
	# This option will be available only on Linux, hence it's declared here:
	OPTION(DISABLE_FTDI "Do not use the USB driver for FTDI chips" 0)
ELSE(UNIX)
	# In windows we always have FTDI support (at compile time at least...)
	SET(CMAKE_MRPT_HAS_FTDI 1)
ENDIF(UNIX)

# Check for the sys/inotify headers (Linux only, in win32
#  we use the equivalent API for file system monitoring):
# =======================================================
IF(UNIX)
	FIND_FILE(INOTIFY_HEADER_FILE sys/inotify.h)
	IF(INOTIFY_HEADER_FILE)
		SET(CMAKE_MRPT_HAS_INOTIFY 1)
		MARK_AS_ADVANCED(INOTIFY_HEADER_FILE)
	ELSE(INOTIFY_HEADER_FILE)
		SET(CMAKE_MRPT_HAS_INOTIFY 0)
	ENDIF(INOTIFY_HEADER_FILE)
ELSE(UNIX)
	# In windows there is no INOTIFY api.
	SET(CMAKE_MRPT_HAS_INOTIFY 0)
ENDIF(UNIX)

# Check for the GL,GLUT libraries (Linux only, in
#  Windows use the build in .h & .lib):
# ===================================================
FIND_PACKAGE(OpenGL)
IF(OPENGL_FOUND AND "${OPENGL_INCLUDE_DIR}")
	INCLUDE_DIRECTORIES("${OPENGL_INCLUDE_DIR}")
ENDIF(OPENGL_FOUND AND "${OPENGL_INCLUDE_DIR}")

IF(UNIX)
	FIND_PACKAGE(GLUT)

	IF (GLUT_FOUND AND OPENGL_gl_LIBRARY AND OPENGL_glu_LIBRARY AND GLUT_glut_LIBRARY)
		INCLUDE_DIRECTORIES("${GLUT_INCLUDE_DIR}")
		SET(CMAKE_MRPT_HAS_OPENGL_GLUT 1)
		SET(CMAKE_MRPT_HAS_GLUT_SYSTEM 1)
	ELSE(GLUT_FOUND AND OPENGL_gl_LIBRARY AND OPENGL_glu_LIBRARY AND GLUT_glut_LIBRARY)
		MESSAGE(STATUS "**Warning**: OpenGL and/or GLUT not found! OpenGL capabilities will be disabled.")
		MESSAGE(STATUS "              	OPENGL_gl_LIBRARY: ${OPENGL_gl_LIBRARY}")
		MESSAGE(STATUS "              	OPENGL_glu_LIBRARY: ${OPENGL_glu_LIBRARY}")
		MESSAGE(STATUS "              	GLUT_glut_LIBRARY: ${GLUT_glut_LIBRARY}")
		MESSAGE(STATUS "              	OPENGL_INCLUDE_DIR: ${OPENGL_INCLUDE_DIR}")

		SET(CMAKE_MRPT_HAS_OPENGL_GLUT 0)
		SET(CMAKE_MRPT_HAS_GLUT_SYSTEM 0)
	ENDIF(GLUT_FOUND AND OPENGL_gl_LIBRARY AND OPENGL_glu_LIBRARY AND GLUT_glut_LIBRARY)
ELSE(UNIX)
	SET(CMAKE_MRPT_HAS_OPENGL_GLUT 1)
	SET(CMAKE_MRPT_HAS_GLUT_SYSTEM 0)
ENDIF(UNIX)


# Check for the OpenCV libraries:
#  pkg-config if available (Linux), otherwise CMake module 
# =========================================================
SET(CMAKE_MRPT_HAS_OPENCV 0)
SET(MRPT_OPENCV_VERSION 0.0.0)
SET(MRPT_OPENCV_VERSION_HEX "0x000")
# Invoke pkg-config for getting the configuration:
IF(PKG_CONFIG_FOUND)
	PKG_CHECK_MODULES(OPENCV opencv)
	IF(OPENCV_FOUND)
		SET(CMAKE_MRPT_HAS_OPENCV 1)
		SET(MRPT_OPENCV_VERSION ${OPENCV_VERSION})
	 
		INCLUDE_DIRECTORIES("${OPENCV_INCLUDEDIR}")
		LINK_DIRECTORIES("${OPENCV_LIBDIR}")
		SET(OpenCV_LIBRARIES ${OPENCV_LIBRARIES})

		MESSAGE(STATUS " opencv include: ${OPENCV_INCLUDE_DIRS} (Version: ${OPENCV_VERSION})")
		INCLUDE_DIRECTORIES(${OPENCV_INCLUDE_DIRS})
	 	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_CFLAGS}")

#		SET(MRPT_LINKER_LIBS_FOR_PKGCONFIG "${MRPT_LINKER_LIBS_FOR_PKGCONFIG} ${opencv_LDFLAGS}")
	ENDIF(OPENCV_FOUND)
ENDIF(PKG_CONFIG_FOUND)

# Use CMAKE module if opencv's not been detected yet:
IF(NOT CMAKE_MRPT_HAS_OPENCV)
	# 1st: Try to find OpenCV config file (NO_MODULE: Don't find a module, but OpenCVConfig.cmake):
	FIND_PACKAGE(OpenCV  QUIET NO_MODULE)
	IF(OpenCV_FOUND)
		SET(MRPT_OPENCV_VERSION ${OpenCV_VERSION})
		SET(OpenCV_LIBRARIES ${OpenCV_LIBS})
		SET(OPENCV_LIBDIR ${OpenCV_LIB_DIR})
		MESSAGE(STATUS "OpenCV ${OpenCV_VERSION} found through OpenCVConfig.cmake")

		SET(CMAKE_MRPT_HAS_OPENCV 1)
	ENDIF(OpenCV_FOUND)
ENDIF(NOT CMAKE_MRPT_HAS_OPENCV)


IF(NOT CMAKE_MRPT_HAS_OPENCV)
	# 2nd: OK, let's use the module:
	FIND_PACKAGE(OpenCV)
	IF(OpenCV_FOUND)
		# MRPT_OPENCV_VERSION
		#MESSAGE(STATUS "OPENCV_EXE_LINKER_FLAGS: ${OPENCV_EXE_LINKER_FLAGS}")
		#MESSAGE(STATUS "OPENCV_INCLUDE_DIR: ${OPENCV_INCLUDE_DIR}")
		#MESSAGE(STATUS "OpenCV_LIBRARIES: ${OpenCV_LIBRARIES}")
	
		FILE(GLOB_RECURSE CV_VER_H "${OpenCV_CXCORE_INCLUDE_DIR}/cvver.h")
		file(READ "${CV_VER_H}" STR_CV_VERSION)

		# Extract the CV version from the cvver.h file, lines "#define CV_MAJOR_VERSION  XX", etc...
		
		#STRING(REGEX MATCHALL "[0-9]+.[0-9]+.[0-9]+" MRPT_OPENCV_VERSION "${STR_CV_VERSION}")
		STRING(REGEX MATCH "CV_MAJOR_VERSION[ ]+[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_MAJOR "${STR_CV_VERSION}")
		STRING(REGEX MATCH "[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_MAJOR "${CMAKE_OPENCV_VERSION_NUMBER_MAJOR}")
		
		STRING(REGEX MATCH "CV_MINOR_VERSION[ ]+[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_MINOR "${STR_CV_VERSION}")
		STRING(REGEX MATCH "[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_MINOR "${CMAKE_OPENCV_VERSION_NUMBER_MINOR}")
		
		STRING(REGEX MATCH "CV_SUBMINOR_VERSION[ ]+[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_PATCH "${STR_CV_VERSION}")
		STRING(REGEX MATCH "[0-9]+" CMAKE_OPENCV_VERSION_NUMBER_PATCH "${CMAKE_OPENCV_VERSION_NUMBER_PATCH}")
	
		SET(MRPT_OPENCV_VERSION "${CMAKE_OPENCV_VERSION_NUMBER_MAJOR}.${CMAKE_OPENCV_VERSION_NUMBER_MINOR}.${CMAKE_OPENCV_VERSION_NUMBER_PATCH}")
		
		MESSAGE(STATUS "OpenCV version detected: ${MRPT_OPENCV_VERSION}")

		SET(CMAKE_MRPT_HAS_OPENCV 1)
	ENDIF(OpenCV_FOUND)
ENDIF(NOT CMAKE_MRPT_HAS_OPENCV)


# Opencv version as Hex. number:
STRING(REGEX MATCHALL "[0-9]+" CMAKE_OPENCV_VERSION_PARTS "${MRPT_OPENCV_VERSION}")
LIST(GET CMAKE_OPENCV_VERSION_PARTS 0 CMAKE_OPENCV_VERSION_NUMBER_MAJOR)
LIST(GET CMAKE_OPENCV_VERSION_PARTS 1 CMAKE_OPENCV_VERSION_NUMBER_MINOR)
LIST(GET CMAKE_OPENCV_VERSION_PARTS 2 CMAKE_OPENCV_VERSION_NUMBER_PATCH)
SET(MRPT_OPENCV_VERSION_HEX "0x${CMAKE_OPENCV_VERSION_NUMBER_MAJOR}${CMAKE_OPENCV_VERSION_NUMBER_MINOR}${CMAKE_OPENCV_VERSION_NUMBER_PATCH}")


# Check for ffmpeg C libraries: libavcodec, libavutil, libavformat, libswscale
#  These libs are linked against mrpt-hwdrivers only (in shared libs,
#  in static all user apps will have to link against this)
# ====================================================================
SET(CMAKE_MRPT_HAS_FFMPEG 0)
SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
SET(MRPT_FFMPEG_LIBS_TO_LINK "")
  
IF(PKG_CONFIG_FOUND)
	PKG_CHECK_MODULES(LIBAVCODEC  libavcodec)
	PKG_CHECK_MODULES(LIBAVUTIL   libavutil)
	PKG_CHECK_MODULES(LIBAVFORMAT libavformat)
	PKG_CHECK_MODULES(LIBSWSCALE  libswscale)
	IF(LIBAVCODEC_FOUND AND LIBAVUTIL_FOUND AND LIBAVFORMAT_FOUND AND LIBSWSCALE_FOUND)
		SET(CMAKE_MRPT_HAS_FFMPEG 1)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 1)
		#MESSAGE(STATUS "libavcodec version: ${LIBAVCODEC_VERSION} ${LIBAVCODEC_INCLUDEDIR}")
	 
		INCLUDE_DIRECTORIES("${LIBAVCODEC_INCLUDEDIR}/")
		INCLUDE_DIRECTORIES("${LIBAVCODEC_INCLUDEDIR}/ffmpeg")
		INCLUDE_DIRECTORIES("${LIBAVCODEC_INCLUDEDIR}/libavcodec")

		INCLUDE_DIRECTORIES("${LIBAVUTIL_INCLUDEDIR}")

		INCLUDE_DIRECTORIES("${LIBAVFORMAT_INCLUDEDIR}")
		INCLUDE_DIRECTORIES("${LIBAVFORMAT_INCLUDEDIR}/ffmpeg")
		INCLUDE_DIRECTORIES("${LIBAVFORMAT_INCLUDEDIR}/libavformat")

		INCLUDE_DIRECTORIES("${LIBSWSCALE_INCLUDEDIR}")
		INCLUDE_DIRECTORIES("${LIBSWSCALE_INCLUDEDIR}/ffmpeg")
		INCLUDE_DIRECTORIES("${LIBSWSCALE_INCLUDEDIR}/libswscale")

		LINK_DIRECTORIES("${LIBAVCODEC_LIBDIR}")
		LINK_DIRECTORIES("${LIBAVUTIL_LIBDIR}")
		LINK_DIRECTORIES("${LIBAVFORMAT_LIBDIR}")
		LINK_DIRECTORIES("${LIBSWSCALE_LIBDIR}")

		SET(MRPT_FFMPEG_LIBS_TO_LINK "${MRPT_FFMPEG_LIBS_TO_LINK}" "${LIBAVCODEC_LIBRARIES}" "${LIBAVFORMAT_LIBRARIES}" "${LIBAVUTIL_LIBRARIES}" "${LIBSWSCALE_LIBRARIES}")

		#MESSAGE(STATUS " ffmpeg libs: ${MRPT_FFMPEG_LIBS_TO_LINK}")
	ENDIF(LIBAVCODEC_FOUND AND LIBAVUTIL_FOUND AND LIBAVFORMAT_FOUND AND LIBSWSCALE_FOUND)
ENDIF(PKG_CONFIG_FOUND)

IF(MSVC)
	SET( MRPT_HAS_FFMPEG_WIN32 OFF CACHE BOOL "Add support for IP cameras and all FFmpeg-capable video sources")
ENDIF(MSVC)

IF(MRPT_HAS_FFMPEG_WIN32)
	SET( FFMPEG_WIN32_ROOT_DIR "" CACHE PATH "Path to FFmpeg win32 build root directory (See http://ffmpeg.arrozcru.org/builds/)")

	# Set to 1, next check for missing things and set to 0 on any error & report message:
	SET(CMAKE_MRPT_HAS_FFMPEG 1)
	SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 1)

	IF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}")
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("The directory 'FFMPEG_WIN32_ROOT_DIR' does not exists. Turn off FFmpeg support or provide the correct path.")
	ENDIF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}")

	IF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavcodec" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavformat" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavutil" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libswscale")
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("The directory 'FFMPEG_WIN32_ROOT_DIR' does not contain include/{libavcodec,libavformat,libavutil,libswscale}. Turn off FFmpeg support or provide the correct path.")
	ENDIF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavcodec" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavformat" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libavutil" OR NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/include/libswscale")

	IF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/lib")
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("The directory 'FFMPEG_WIN32_ROOT_DIR' does not contain /lib/. Turn off FFmpeg support or provide the correct path.")
	ENDIF(NOT EXISTS "${FFMPEG_WIN32_ROOT_DIR}/lib")
	
	# We need the .lib files: avcodec-52.lib, avformat-52.lib, avutil-49.lib, swscale-0.lib
	FILE(GLOB FFMPEG_WIN32_AVCODEC_LIB "${FFMPEG_WIN32_ROOT_DIR}/lib/avcodec*.lib")
	FILE(GLOB FFMPEG_WIN32_AVUTIL_LIB "${FFMPEG_WIN32_ROOT_DIR}/lib/avutil*.lib")
	FILE(GLOB FFMPEG_WIN32_AVFORMAT_LIB "${FFMPEG_WIN32_ROOT_DIR}/lib/avformat*.lib")
	FILE(GLOB FFMPEG_WIN32_SWSCALE_LIB "${FFMPEG_WIN32_ROOT_DIR}/lib/swscale*.lib")
			
	IF (NOT EXISTS ${FFMPEG_WIN32_AVCODEC_LIB})
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("avcodec-XX.lib not found under '${FFMPEG_WIN32_ROOT_DIR}/lib'. Turn off FFmpeg support or provide the correct path.")
	ENDIF (NOT EXISTS ${FFMPEG_WIN32_AVCODEC_LIB})

	IF (NOT EXISTS ${FFMPEG_WIN32_AVUTIL_LIB})
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("avutil-XX.lib not found under '${FFMPEG_WIN32_ROOT_DIR}/lib'. Turn off FFmpeg support or provide the correct path.")
	ENDIF (NOT EXISTS ${FFMPEG_WIN32_AVUTIL_LIB})

	IF (NOT EXISTS ${FFMPEG_WIN32_AVFORMAT_LIB})
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("avformat-XX.lib not found under '${FFMPEG_WIN32_ROOT_DIR}/lib'. Turn off FFmpeg support or provide the correct path.")
	ENDIF (NOT EXISTS ${FFMPEG_WIN32_AVFORMAT_LIB})

	IF (NOT EXISTS ${FFMPEG_WIN32_SWSCALE_LIB})
		SET(CMAKE_MRPT_HAS_FFMPEG 0)
		SET(CMAKE_MRPT_HAS_FFMPEG_SYSTEM 0)
		MESSAGE("swscale-XX.lib not found under '${FFMPEG_WIN32_ROOT_DIR}/lib'. Turn off FFmpeg support or provide the correct path.")
	ENDIF (NOT EXISTS ${FFMPEG_WIN32_SWSCALE_LIB})
	
	INCLUDE_DIRECTORIES("${FFMPEG_WIN32_ROOT_DIR}/include")
	INCLUDE_DIRECTORIES("${FFMPEG_WIN32_ROOT_DIR}/include/libavcodec")
	INCLUDE_DIRECTORIES("${FFMPEG_WIN32_ROOT_DIR}/include/libavformat")
	INCLUDE_DIRECTORIES("${FFMPEG_WIN32_ROOT_DIR}/include/libavutil")
	INCLUDE_DIRECTORIES("${FFMPEG_WIN32_ROOT_DIR}/include/libswscale")

	SET(MRPT_FFMPEG_LIBS_TO_LINK ${MRPT_FFMPEG_LIBS_TO_LINK} "${FFMPEG_WIN32_AVCODEC_LIB}" "${FFMPEG_WIN32_AVUTIL_LIB}" "${FFMPEG_WIN32_AVFORMAT_LIB}" "${FFMPEG_WIN32_SWSCALE_LIB}")
ENDIF(MRPT_HAS_FFMPEG_WIN32)


# Check for system lib3ds:
# ===================================================
SET(CMAKE_MRPT_HAS_LIB3DS 1)	# Always present: system or built-in

# Check for system zlib:
# ===================================================
SET(CMAKE_MRPT_HAS_ZLIB 1)	# Always present: system or built-in

# Check for system jpeglib:
# ===================================================
SET(CMAKE_MRPT_HAS_JPEG 1)	# Always present: system or built-in

# Check for wxWidgets + GL
#  If it is found, will set CMAKE_MRPT_HAS_WXWIDGETS=1
# ===================================================
# Here you can define what libraries of wxWidgets you need for your application. 
#  You can figure out what libraries you need here;  http://www.wxwidgets.org/manuals/2.8/wx_librarieslist.html
SET(wxWidgets_MRPT_COMPONENTS_TO_SEARCH "base;core;gl;adv;aui" CACHE STRING "Components to search in wxWidgets")

IF(UNIX)
	# Linux:
	IF(CMAKE_BUILD_TYPE MATCHES "Debug")
		SET(wxWidgets_USE_DEBUG ON)
	ENDIF(CMAKE_BUILD_TYPE MATCHES "Debug")
ELSE(UNIX)
	# Windows configuration of wxWidgets:
	SET(wxWidgets_USE_REL_AND_DBG ON)
ENDIF(UNIX)

# Make things easier: If we are building for MSVC, select the vc_lib or vc_dll directory automatically:
if(msvc)
	if(BUILD_SHARED_LIBS)
		set(wxWidgets_LIB_DIR "${wxWidgets_ROOT_DIR}/lib/vc_dll" FORCE)
	else(BUILD_SHARED_LIBS)
		set(wxWidgets_LIB_DIR "${wxWidgets_ROOT_DIR}/lib/vc_lib" FORCE)
	endif(BUILD_SHARED_LIBS)
endif(msvc)


# We need the Find package for wxWidgets to work
FIND_PACKAGE(wxWidgets COMPONENTS "${wxWidgets_MRPT_COMPONENTS_TO_SEARCH}")
# Did we find wxWidgets ? This condition will fail for as long as the internal vars do not point to the proper wxWidgets configuration
IF(wxWidgets_FOUND)
	# Check for non-found debug libs:
	IF(UNIX)
		IF(CMAKE_BUILD_TYPE MATCHES "Debug")
			IF(NOT wxWidgets_USE_DEBUG)
				MESSAGE("Warning: The debug libraries for wxWidgets couldn't be found by CMake. Please install them (libwxbase2.8-dev) or build in release.")
			ENDIF(NOT wxWidgets_USE_DEBUG)
		ENDIF(CMAKE_BUILD_TYPE MATCHES "Debug")
	ENDIF(UNIX)

	# Include wxWidgets macros
	INCLUDE(${wxWidgets_USE_FILE})
	# ${wxWidgets_LIBRARIES}  will contain the libraries that should be added through TARGET_LINK_LIBRARIES(...)
	MESSAGE(STATUS "wxWidgets:")
	MESSAGE(STATUS "   wxWidgets_LIBRARY_DIRS  : ${wxWidgets_LIBRARY_DIRS}")
	MESSAGE(STATUS "   wxWidgets_CXX_FLAGS     : ${wxWidgets_CXX_FLAGS}")
	MESSAGE(STATUS "   wxWidgets_INCLUDE_DIRS  : ${wxWidgets_INCLUDE_DIRS}")

	LINK_DIRECTORIES(${wxWidgets_LIBRARY_DIRS})

	IF(MSVC)
		ADD_DEFINITIONS(-DwxUSE_NO_MANIFEST=1)
	ENDIF(MSVC)

	IF(CMAKE_COMPILER_IS_GNUCXX)
		# Add -isystem for wx headers (seems not to be added automatically for GCC in mac osx)
		FOREACH(WXDIR ${wxWidgets_INCLUDE_DIRS})
			SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${WXDIR} -isystem ${WXDIR}")
		ENDFOREACH(WXDIR)
	ENDIF(CMAKE_COMPILER_IS_GNUCXX)

	# For use in the MRPTconfig.cmake
	SET(CMAKE_MRPT_WX_ROOT_DIR ${wxWidgets_ROOT_DIR})

	SET(CMAKE_MRPT_HAS_WXWIDGETS 1)
ELSE(wxWidgets_FOUND)
	# Monolithic?	
	IF (WX_mono)
		SET(wxWidgets_MRPT_COMPONENTS_TO_SEARCH mono CACHE STRING "Components to search in wxWidgets" FORCE)
		FIND_PACKAGE(wxWidgets COMPONENTS ${wxWidgets_MRPT_COMPONENTS_TO_SEARCH})

		INCLUDE(${wxWidgets_USE_FILE})
		# ${wxWidgets_LIBRARIES}  will contain the libraries that should be added through TARGET_LINK_LIBRARIES(...)
		#MESSAGE(STATUS "wxWidgets_LIBRARIES: ${wxWidgets_LIBRARIES}")
		#MESSAGE(STATUS "wxWidgets_CXX_FLAGS: ${wxWidgets_CXX_FLAGS}")

		LINK_DIRECTORIES(${wxWidgets_LIBRARY_DIRS})

		IF(MSVC)
			ADD_DEFINITIONS(-DwxUSE_NO_MANIFEST=1)
		ENDIF(MSVC)

		# For use in the MRPTconfig.cmake
		SET(CMAKE_MRPT_WX_ROOT_DIR ${wxWidgets_ROOT_DIR})

		SET(CMAKE_MRPT_HAS_WXWIDGETS 1)

	ELSE(WX_mono)
		MESSAGE("wxWidgets was not found automatically. Please, set wxWidgets_ROOT_DIR to the lib directory to enable it in MRPT.")
		SET(CMAKE_MRPT_HAS_WXWIDGETS 0)
	ENDIF(WX_mono)
ENDIF(wxWidgets_FOUND)


# Let the user disable SSE2
# ===================================================
SET(CMAKE_MRPT_HAS_SSE2 1)
SET(DISABLE_SSE2 OFF CACHE BOOL "Forces compilation WITHOUT SSE2/MMX extensions")
MARK_AS_ADVANCED(DISABLE_SSE2)
IF(DISABLE_SSE2)
	SET(CMAKE_MRPT_HAS_SSE2 0)
ENDIF(DISABLE_SSE2)


# Detect support for OpenMP:
# ===================================================
FIND_PACKAGE(OpenMP QUIET)
IF (NOT OPENMP_FOUND)
	SET(CMAKE_MRPT_HAS_OPENMP 0)
ELSE(NOT OPENMP_FOUND)
	# Let the user disable OpenMP
	# ===================================================
	SET(CMAKE_MRPT_HAS_OPENMP 1)
	SET(DISABLE_OPENMP OFF CACHE BOOL "Forces compilation WITHOUT OpenMP")
	MARK_AS_ADVANCED(DISABLE_OPENMP)
	IF(DISABLE_OPENMP)
		SET(CMAKE_MRPT_HAS_OPENMP 0)
	ENDIF(DISABLE_OPENMP)
ENDIF (NOT OPENMP_FOUND)

IF(CMAKE_MRPT_HAS_OPENMP)
	SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
ENDIF(CMAKE_MRPT_HAS_OPENMP)


# DISABLE_WXWIDGETS
# ---------------------
SET( DISABLE_WXWIDGETS OFF CACHE BOOL "Forces compilation WITHOUT wxWidgets")
MARK_AS_ADVANCED(DISABLE_WXWIDGETS)
IF(DISABLE_WXWIDGETS)
	SET(CMAKE_MRPT_HAS_WXWIDGETS 0)
	SET(wxWidgets_LIBRARIES "")
ENDIF(DISABLE_WXWIDGETS)

# Check for libdc1394-2 (Only in Linux, there is no 
#  Windows version yet...)
# ===================================================
SET(CMAKE_MRPT_HAS_LIBDC1394_2 0)
# Invoke pkg-config for getting the configuration:
IF(PKG_CONFIG_FOUND)
	PKG_CHECK_MODULES(LIBDC1394_2 libdc1394-2)
	IF (LIBDC1394_2_FOUND)
		SET(CMAKE_MRPT_HAS_LIBDC1394_2 1)
		#MESSAGE(STATUS "LIBDC1394_2_LIBRARIES    : ${LIBDC1394_2_LIBRARIES}")
		#MESSAGE(STATUS "LIBDC1394_2_INCLUDE_DIRS : ${LIBDC1394_2_INCLUDE_DIRS}")
		#MESSAGE(STATUS "LIBDC1394_2_LIBRARY_DIRS : ${LIBDC1394_2_LIBRARY_DIRS}")
		#MESSAGE(STATUS "LIBDC1394_2_LDFLAGS      : ${LIBDC1394_2_LDFLAGS}")


		IF ("${LIBDC1394_2_INCLUDE_DIRS}")
			INCLUDE_DIRECTORIES("${LIBDC1394_2_INCLUDE_DIRS}")
		ENDIF ("${LIBDC1394_2_INCLUDE_DIRS}")

		IF ("${LIBDC1394_2_LIBRARY_DIRS}")
			LINK_DIRECTORIES("${LIBDC1394_2_LIBRARY_DIRS}")
		ENDIF ("${LIBDC1394_2_LIBRARY_DIRS}")

#		SET(MRPT_LINKER_LIBS_FOR_PKGCONFIG "${MRPT_LINKER_LIBS_FOR_PKGCONFIG} ${LIBDC1394_2_LDFLAGS}")
	ELSE(LIBDC1394_2_FOUND)
		SET(CMAKE_MRPT_HAS_LIBDC1394_2 0)
	ENDIF (LIBDC1394_2_FOUND)
ENDIF(PKG_CONFIG_FOUND)


# ---------------------------------------------------------------------------
#			OPTIONS
#The options for the user when using "cmakesetup" or "ccmake":
# ---------------------------------------------------------------------------
OPTION(MRPT_ALWAYS_CHECKS_DEBUG "Additional checks even in Release" "OFF")
OPTION(MRPT_ALWAYS_CHECKS_DEBUG_MATRICES "Additional checks even in Release (Only in matrix classes)" "ON")
OPTION(DISABLE_OPENCV "Disable the OpenCV library" "OFF")
MARK_AS_ADVANCED(DISABLE_OPENCV)


# ---------------------------------------------------------------------------
#  Parse the value of options to disable stuff:
# ---------------------------------------------------------------------------
IF(DISABLE_OPENCV)
	SET(CMAKE_MRPT_HAS_OPENCV 0)
ENDIF(DISABLE_OPENCV)


OPTION(DISABLE_OPENGL "Disable the OpenGL library" "OFF")
MARK_AS_ADVANCED(DISABLE_OPENGL)


# ---------------------------------------------------------------------------
#  Parse the value of options to disable stuff:
# ---------------------------------------------------------------------------
IF(DISABLE_OPENGL)
	SET(CMAKE_MRPT_HAS_OPENGL_GLUT 0)
ENDIF(DISABLE_OPENGL)


# By default, compile this library if the directory exist:
# It will be not present in Debian packages due to legal restrictions:
# ------------------------------------------------------------------------
IF(EXISTS "${MRPT_LIBS_ROOT}/vision/src/sift-hess")
	SET( CMAKE_MRPT_HAS_SIFT_HESS 1)
ELSE(EXISTS "${MRPT_LIBS_ROOT}/vision/src/sift-hess")
	SET( CMAKE_MRPT_HAS_SIFT_HESS 0)
ENDIF(EXISTS "${MRPT_LIBS_ROOT}/vision/src/sift-hess")

IF(NOT CMAKE_MRPT_HAS_OPENCV)
	SET( CMAKE_MRPT_HAS_SIFT_HESS 0)
ENDIF(NOT CMAKE_MRPT_HAS_OPENCV)

OPTION(DISABLE_SIFT_HESS "Disable the Hess' SIFT library" "OFF")
MARK_AS_ADVANCED(DISABLE_SIFT_HESS)
IF(DISABLE_SIFT_HESS)
	SET(CMAKE_MRPT_HAS_SIFT_HESS 0)
ENDIF(DISABLE_SIFT_HESS)



# ---------------------------------------------------------------------------
# Create the minimum list of libraries required by an application that
#  uses the MRPT C++ library. This must be passed to "TARGET_LINK_LIBRARIES"
# NOTE: For the compilers MSVC* & Borland most of the libraries are
#        automatically included through "#pragma"'s ;-)
# ---------------------------------------------------------------------------
IF(WIN32)
    # glut (for windows): Built-in
	INCLUDE_DIRECTORIES("${MRPT_SOURCE_DIR}/include/mrpt/otherlibs/glut/")
ENDIF(WIN32)

IF(MSVC OR BORLAND)
	SET(MRPT_LINKER_LIBS "")
	SET(MRPT_LINKER_LIBS_FOR_PKGCONFIG "")

	IF(CMAKE_MRPT_HAS_ZLIB)
		#INCLUDE_DIRECTORIES("${MRPT_SOURCE_DIR}/src/base/compress/zlib/")
		SET(CMAKE_MRPT_HAS_ZLIB_SYSTEM 0)
	ENDIF(CMAKE_MRPT_HAS_ZLIB)

	IF(CMAKE_MRPT_HAS_JPEG)
		SET(CMAKE_MRPT_HAS_JPEG_SYSTEM 0)
	ENDIF(CMAKE_MRPT_HAS_JPEG)

ELSE(MSVC OR BORLAND)

	# GL, GLU, glut:
	IF(CMAKE_MRPT_HAS_OPENGL_GLUT)
		APPEND_MRPT_LIBS(${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY} ${GLUT_glut_LIBRARY})
	ENDIF(CMAKE_MRPT_HAS_OPENGL_GLUT)

	# FTDI:
	IF(CMAKE_MRPT_HAS_FTDI)
		IF (UNIX)
			# ${CMAKE_FTDI_LIBS}
			APPEND_MRPT_LIBS(ftdi usb)
		ELSE(UNIX)
			# Nothing...
		ENDIF(UNIX)
	ENDIF(CMAKE_MRPT_HAS_FTDI)

	# ZLIB:
	FIND_PACKAGE(ZLIB)
	IF(ZLIB_FOUND)
			MESSAGE(STATUS "Found library: zlib - Include: ${ZLIB_INCLUDE_DIR}")

			INCLUDE_DIRECTORIES("${ZLIB_INCLUDE_DIR}")
			
			APPEND_MRPT_LIBS(z)

			SET(CMAKE_MRPT_HAS_ZLIB_SYSTEM 1)
	ELSE(ZLIB_FOUND)
			#INCLUDE_DIRECTORIES("${MRPT_SOURCE_DIR}/src/base/compress/zlib/")

			# If we are using a static version of wxWidgets we dont need this... for now check if this is MinGW on Windows...
			#IF (NOT WIN32 OR NOT CMAKE_MRPT_HAS_WXWIDGETS)
			#	APPEND_MRPT_LIBS(optimized mrpt-zlib debug mrpt-zlib-dbg)
			#ENDIF(NOT WIN32 OR NOT CMAKE_MRPT_HAS_WXWIDGETS)

			SET(CMAKE_MRPT_HAS_ZLIB_SYSTEM 0)
	ENDIF(ZLIB_FOUND)
	
	# JPEG:
	FIND_PACKAGE(JPEG)
	IF(JPEG_FOUND)
			MESSAGE(STATUS "Found library: jpeg  - Include: ${JPEG_INCLUDE_DIR}")

			INCLUDE_DIRECTORIES("${JPEG_INCLUDE_DIR}")
			
			APPEND_MRPT_LIBS(jpeg)

			SET(CMAKE_MRPT_HAS_JPEG_SYSTEM 1)
	ELSE(JPEG_FOUND)
			SET(CMAKE_MRPT_HAS_JPEG_SYSTEM 0)
	ENDIF(JPEG_FOUND)

	# In Linux, link against librt
	IF(UNIX)
		APPEND_MRPT_LIBS(rt)
	ENDIF(UNIX)
	
	# In Windows, link against ole32 & uuid & oleaut32, etc...
	IF(MINGW)
		APPEND_MRPT_LIBS(ole32 uuid oleaut32 gdi32 winmm setupapi)
		#ADD_DEFINITIONS(-D__MSVCRT_VERSION__=0x7000)
	ENDIF(MINGW)
	
ENDIF(MSVC OR BORLAND)

# OpenCV (all compilers):
IF(CMAKE_MRPT_HAS_OPENCV)
	INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIR})
	APPEND_MRPT_LIBS(${OpenCV_LIBRARIES})
	
	MESSAGE(STATUS "OpenCV:")
	MESSAGE(STATUS "        OpenCV_LIBRARIES:   ${OpenCV_LIBRARIES}")
	MESSAGE(STATUS "        OpenCV_INCLUDE_DIR: ${OpenCV_INCLUDE_DIR}")
	
	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCV_EXE_LINKER_FLAGS}")

	SET(CMAKE_MRPT_HAS_OPENCV_SYSTEM 1)

	# http://www.mip.informatik.uni-kiel.de/~jw/cmake/CMakeModules/DefineFlags.cmake
	IF(MSVC)
		# required for precompiled OpenCV usage, jw
		STRING_APPEND( CMAKE_EXE_LINKER_FLAGS_DEBUG      "/NODEFAULTLIB:\"libc.lib\"")
		STRING_APPEND( CMAKE_EXE_LINKER_FLAGS_RELEASE    "/NODEFAULTLIB:\"libcd.lib\"")
		STRING_APPEND( CMAKE_SHARED_LINKER_FLAGS_DEBUG   "/NODEFAULTLIB:\"libc.lib\"")
		STRING_APPEND( CMAKE_SHARED_LINKER_FLAGS_RELEASE "/NODEFAULTLIB:\"libcd.lib\"")
	ENDIF(MSVC)

ENDIF(CMAKE_MRPT_HAS_OPENCV)

# libs for libdc1394:
IF (LIBDC1394_2_FOUND)
	APPEND_MRPT_LIBS( ${LIBDC1394_2_LIBRARIES} )
ENDIF (LIBDC1394_2_FOUND)


# Support for SWISSRANGE 3D camera:
# ===================================================
SET(CMAKE_MRPT_HAS_SWISSRANGE 0)

IF(UNIX)
	# Linux: Look for the libMesaSR.h include:
	FIND_FILE(SWR_HEADER_FILE  libMesaSR.h)
	IF(SWR_HEADER_FILE)
		SET(CMAKE_MRPT_HAS_SWISSRANGE 1)
		MARK_AS_ADVANCED(SWR_HEADER_FILE)
		APPEND_MRPT_LIBS(mesasr)
	ELSE(SWR_HEADER_FILE)
		SET(CMAKE_MRPT_HAS_SWISSRANGE 0)
	ENDIF(SWR_HEADER_FILE)
ELSE(UNIX)
	IF (MSVC)
		# Windows: ...
		FIND_PATH(SWR_LIBMESASR_DIR  MesaImaging/Swissranger/libMesaSR/)
		
		IF(SWR_LIBMESASR_DIR)
			SET(SWR_LIBMESASR_DIR "${SWR_LIBMESASR_DIR}/MesaImaging/Swissranger/libMesaSR/")
			MESSAGE(STATUS "SwissRanger Library found in: ${SWR_LIBMESASR_DIR}")			
			
			# We expect to find there "libMesaSR.lib" & "libMesaSR.h"
			IF (EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.lib" AND EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.h")
				SET(CMAKE_MRPT_HAS_SWISSRANGE 1)
				INCLUDE_DIRECTORIES("${SWR_LIBMESASR_DIR}")
				#LINK_DIRECTORIES("${SWR_LIBMESASR_DIR}")
				APPEND_MRPT_LIBS("${SWR_LIBMESASR_DIR}/libMesaSR.lib")
				MARK_AS_ADVANCED(SWR_LIBMESASR_DIR)
			ELSE (EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.lib" AND EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.h")
				MESSAGE(STATUS "*** ERROR *** SwissRanger Library directory found but doesn't contain expected files. Not using it.")
				SET(CMAKE_MRPT_HAS_SWISSRANGE 0)
			ENDIF (EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.lib" AND EXISTS "${SWR_LIBMESASR_DIR}/libMesaSR.h")
		ELSE(SWR_LIBMESASR_DIR)
			SET(CMAKE_MRPT_HAS_SWISSRANGE 0)
		ENDIF(SWR_LIBMESASR_DIR)
	ENDIF(MSVC)
ENDIF(UNIX)


# We have gz-streams is we have zlib:
# ------------------------------------------
SET(CMAKE_MRPT_HAS_GZ_STREAMS ${CMAKE_MRPT_HAS_ZLIB})


# WXWIDGETS+GL: Add libraries
# -------------------------------------------
IF(CMAKE_MRPT_HAS_WXWIDGETS)
	LIST(LENGTH wxWidgets_LIBRARIES wxLibsCount)
	if (wxLibsCount GREATER 0)
		APPEND_MRPT_LIBS(${wxWidgets_LIBRARIES})

		FOREACH(WXLIB ${wxWidgets_LIBRARIES})
			SET(MRPT_LINKER_LIBS_FOR_PKGCONFIG "${MRPT_LINKER_LIBS_FOR_PKGCONFIG} ${WXLIB}")
		ENDFOREACH(WXLIB)
		
	endif(wxLibsCount GREATER 0)
ENDIF(CMAKE_MRPT_HAS_WXWIDGETS)

# Save the basic list of libraries (without MRPT-libs):
# -------------------------------------------------------------------------------------
SET(MRPTLIB_LINKER_LIBS ${MRPT_LINKER_LIBS} ${MRPT_FFMPEG_LIBS_TO_LINK})
#MESSAGE(STATUS "MRPTLIB_LINKER_LIBS: ${MRPTLIB_LINKER_LIBS}")

# If we are building .so libs, don't link every program to all the libs:
IF(BUILD_SHARED_LIBS)
	SET(MRPT_LINKER_LIBS "")
ENDIF(BUILD_SHARED_LIBS)
 

IF(NOT MSVC AND NOT BORLAND)	
	FOREACH(_LIB ${ALL_MRPT_LIBS})
		LIST(APPEND MRPT_LINKER_LIBS_FOR_PKGCONFIG "-l${_LIB}")
	ENDFOREACH(_LIB)
ENDIF(NOT MSVC AND NOT BORLAND)

# Save the list of libraries according to the current debug/release build (gcc only)
# -------------------------------------------------------------------------------------
SET(MRPT_LINKER_LIBS_RELorDEB ${MRPT_LINKER_LIBS})

IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
	SET(MRPT_LINKER_LIBS_POSTFIX "${MRPT_DEBUG_POSTFIX}")
ELSE(CMAKE_BUILD_TYPE STREQUAL "Debug")
	SET(MRPT_LINKER_LIBS_POSTFIX "")
ENDIF(CMAKE_BUILD_TYPE STREQUAL "Debug")

# Detect wordsize:
# -------------------------------------------
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)  # Size in bytes!
	SET(CMAKE_MRPT_WORD_SIZE 64)
ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)  # Size in bytes!
	SET(CMAKE_MRPT_WORD_SIZE 32)
ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)


# ---------------------------------------------------------------
#   "Clasic" function & headers detection:
# ---------------------------------------------------------------
INCLUDE (CheckFunctionExists)
INCLUDE (CheckIncludeFile)
INCLUDE (CheckTypeSize)

SET(CMAKE_REQUIRED_INCLUDES "math.h")
if(CMAKE_COMPILER_IS_GNUCXX)
	SET(CMAKE_REQUIRED_LIBRARIES "m")
endif(CMAKE_COMPILER_IS_GNUCXX)

CHECK_FUNCTION_EXISTS(timegm HAVE_TIMEGM)
CHECK_FUNCTION_EXISTS(_mkgmtime HAVE_MKGMTIME)
CHECK_FUNCTION_EXISTS(alloca HAVE_ALLOCA_FUNC)
CHECK_FUNCTION_EXISTS(gettid HAVE_GETTID)
CHECK_FUNCTION_EXISTS(sincos HAVE_SINCOS)
CHECK_FUNCTION_EXISTS(lrint HAVE_LRINT)
CHECK_FUNCTION_EXISTS(erf HAVE_ERF)
CHECK_FUNCTION_EXISTS(posix_memalign HAVE_POSIX_MEMALIGN)
CHECK_FUNCTION_EXISTS(_aligned_malloc HAVE_ALIGNED_MALLOC)

#  This seems not to work and is more complex than it looks at first sight... :-(
#SET(CMAKE_REQUIRED_INCLUDES "windows.h")
#SET(CMAKE_REQUIRED_LIBRARIES kernel32)
#CHECK_FUNCTION_EXISTS(OpenThread HAVE_OPENTHREAD)

if(MSVC AND NOT MSVC6 AND NOT MSVC7)
	SET(HAVE_OPENTHREAD 1) 
else(MSVC AND NOT MSVC6 AND NOT MSVC7)
	SET(HAVE_OPENTHREAD 0) 
endif(MSVC AND NOT MSVC6 AND NOT MSVC7)



CHECK_INCLUDE_FILE("alloca.h" HAVE_ALLOCA_H)
CHECK_INCLUDE_FILE("linux/serial.h" HAVE_LINUX_SERIAL_H)

IF(HAVE_ALLOCA_FUNC OR HAVE_ALLOCA_H)
	SET(HAVE_ALLOCA 1)
ENDIF(HAVE_ALLOCA_FUNC OR HAVE_ALLOCA_H)

if(CMAKE_MRPT_HAS_GLUT_SYSTEM)
	SET(HAVE_FREEGLUT_EXT_H 0)
	FIND_FILE(FREEGLUTEXT_HFILE GL/freeglut_ext.h)
	if(FREEGLUTEXT_HFILE)
		SET(HAVE_FREEGLUT_EXT_H 1)
	endif(FREEGLUTEXT_HFILE)
else(CMAKE_MRPT_HAS_GLUT_SYSTEM)
	SET(HAVE_FREEGLUT_EXT_H 1)
endif(CMAKE_MRPT_HAS_GLUT_SYSTEM)

CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H)
CHECK_INCLUDE_FILE("winsock2.h" HAVE_WINSOCK2_H)

# If we want SSE2, check for the expected headers:
IF (CMAKE_MRPT_HAS_SSE2)
	CHECK_INCLUDE_FILE("emmintrin.h" HAVE_EMMINTRIN_H)
	CHECK_INCLUDE_FILE("mmintrin.h"  HAVE_MMINTRIN_H)
	
	# If the headers are not found, disable optimizations:
	IF (NOT HAVE_MMINTRIN_H OR NOT HAVE_EMMINTRIN_H)
		SET(CMAKE_MRPT_HAS_SSE2 0)
	ENDIF(NOT HAVE_MMINTRIN_H OR NOT HAVE_EMMINTRIN_H)
ENDIF(CMAKE_MRPT_HAS_SSE2)


# Compiler type sizes:
check_type_size("long double"  HAVE_LONG_DOUBLE)


# ---------------------------------------------------------------
#   detect endian-ness
# ---------------------------------------------------------------
INCLUDE(TestBigEndian)
TEST_BIG_ENDIAN(CMAKE_MRPT_IS_BIG_ENDIAN)



# ----------------------------------------------------------------------------
# Transform the variables MRPT_XXX="ON/OFF" to CMAKE_MRPT_XXX="1/0"
# ----------------------------------------------------------------------------
MACRO(CREATE_CMAKE_MRPT_DEFINE defName)
	IF(${defName} MATCHES "ON")
		SET(CMAKE_${defName} "1")
	ELSE(${defName} MATCHES "ON")
		SET(CMAKE_${defName} "0")
	ENDIF(${defName} MATCHES "ON")
ENDMACRO(CREATE_CMAKE_MRPT_DEFINE)

CREATE_CMAKE_MRPT_DEFINE(MRPT_ALWAYS_CHECKS_DEBUG)
CREATE_CMAKE_MRPT_DEFINE(MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
CREATE_CMAKE_MRPT_DEFINE(MRPT_HAS_BUMBLEBEE)
CREATE_CMAKE_MRPT_DEFINE(MRPT_HAS_ASSERT)
CREATE_CMAKE_MRPT_DEFINE(MRPT_HAS_STACKED_EXCEPTIONS)
CREATE_CMAKE_MRPT_DEFINE(MRPT_ENABLE_EMBEDDED_GLOBAL_PROFILER)
CREATE_CMAKE_MRPT_DEFINE(MRPT_HAS_ASIAN_FONTS)
CREATE_CMAKE_MRPT_DEFINE(CMAKE_MRPT_HAS_INOTIFY)


# ----------------------------------------------------------------------------
#   				UPDATE CONFIG FILES & SCRIPTS:
#
#  CONFIGURE_FILE(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
# If @ONLY is specified, only variables of the form @VAR@ will be
#  replaces and ${VAR} will be ignored.
#
#  A directory will be created for each platform so the "config.h" file is
#   not overwritten if cmake generates code in the same path.
# ----------------------------------------------------------------------------
SET(MRPT_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/mrpt-config/" CACHE PATH "Where to create the platform-dependant config.h")
IF(UNIX)
	SET(MRPT_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/mrpt-config/unix/" )
ENDIF(UNIX)
IF (WIN32)
	SET(MRPT_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/mrpt-config/win32/")
ENDIF(WIN32)

FILE(MAKE_DIRECTORY  "${MRPT_CONFIG_FILE_INCLUDE_DIR}")
FILE(MAKE_DIRECTORY  "${MRPT_CONFIG_FILE_INCLUDE_DIR}/mrpt")

#MESSAGE(STATUS "Parsing 'config.h.in'")
CONFIGURE_FILE("${CMAKE_SOURCE_DIR}/parse-files/config.h.in" "${MRPT_CONFIG_FILE_INCLUDE_DIR}/mrpt/config.h")

# ----------------------------------------------------------------------------
#  Update the library version header file
#    FILE_TO_PARSE="SRC/include/mrpt/MRPT_version.h.in"
#    TARGET_FILE  ="MRPT_version.h"
# ----------------------------------------------------------------------------
#SET(CMAKE_MRPT_COMPLETE_NAME "MRPT ${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH} ${CMAKE_MRPT_SVNVERSION}")
SET(CMAKE_MRPT_COMPLETE_NAME "MRPT ${CMAKE_MRPT_VERSION_NUMBER_MAJOR}.${CMAKE_MRPT_VERSION_NUMBER_MINOR}.${CMAKE_MRPT_VERSION_NUMBER_PATCH}") # Without the SVN number, avoids recompiling the whole thing with each commit/update.

# Build a three digits version code, eg. 0.5.1 -> 051,  1.2.0 -> 120
SET(CMAKE_MRPT_VERSION_CODE "0x${CMAKE_MRPT_VERSION_NUMBER_MAJOR}${CMAKE_MRPT_VERSION_NUMBER_MINOR}${CMAKE_MRPT_VERSION_NUMBER_PATCH}")

#MESSAGE(STATUS "Parsing 'version.h.in'")
CONFIGURE_FILE("${CMAKE_SOURCE_DIR}/parse-files/version.h.in" "${MRPT_CONFIG_FILE_INCLUDE_DIR}/mrpt/version.h")


# ---------------------------------------------------------------------------
# The C++ include & link directories:
# ---------------------------------------------------------------------------
INCLUDE_DIRECTORIES(".")
INCLUDE_DIRECTORIES("${MRPT_CONFIG_FILE_INCLUDE_DIR}")

LINK_DIRECTORIES("${CMAKE_BINARY_DIR}/lib")

IF(CMAKE_MRPT_HAS_BUMBLEBEE)
	INCLUDE_DIRECTORIES("${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/include")
	INCLUDE_DIRECTORIES("${BUMBLEBEE_TRICLOPS_ROOT_DIR}/include")

	LINK_DIRECTORIES("${BUMBLEBEE_PGR_FLYCAPTURE_ROOT_DIR}/lib")
	LINK_DIRECTORIES("${BUMBLEBEE_TRICLOPS_ROOT_DIR}/lib")
ENDIF(CMAKE_MRPT_HAS_BUMBLEBEE)

# Add user supplied extra options (optimization, etc...)
# ==========================================================
SET(USER_EXTRA_CPP_FLAGS "" CACHE STRING "Put extra compiler options here if desired")

# ----------------------------------------------------------------------------
# 			Set the maximum level of warnings:
# ----------------------------------------------------------------------------
SET( MRPT_EXTRA_WARNINGS OFF CACHE BOOL "Enable extra warnings apart from -Wall")

# Should be set to true for development
SET( MRPT_WARNINGS_ARE_ERRORS OFF CACHE BOOL "Treat warnings as errors")

# Whole program optimization?
SET( MRPT_WHOLE_PROGRAM_OPTIMIZATION OFF CACHE BOOL "Flags for whole program optimization.")

# Include Asian fonts in utils::CMRPTCanvas ?
SET( MRPT_HAS_ASIAN_FONTS ON CACHE BOOL "Enable Asian fonts in utils::CMRPTCanvas (increases library size).")


IF(MSVC)
	SET(EXTRA_CPP_FLAGS "/W3 /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE")

	# Whole program optimization
	IF(MRPT_WHOLE_PROGRAM_OPTIMIZATION AND MSVC)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} /GL")
		SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG ")
		#SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG ")
		SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LTCG ")
		#SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /LTCG ")
		SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LTCG ")
	ENDIF(MRPT_WHOLE_PROGRAM_OPTIMIZATION AND MSVC)

	# Remove unreferenced functions: function level linking
	SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} /Gy")
	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 ")

	# SSE2?
	IF (CMAKE_MRPT_HAS_SSE2 AND NOT CMAKE_MRPT_WORD_SIZE EQUAL 64)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} /arch:SSE2")
	ENDIF(CMAKE_MRPT_HAS_SSE2 AND NOT CMAKE_MRPT_WORD_SIZE EQUAL 64)
	
	# Fast math:
	#SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} /fp:fast")
	
ENDIF(MSVC)

IF(CMAKE_COMPILER_IS_GNUCXX)


	# Wall & pedantic?
	IF(APPLE)
		SET(MRPT_BUILD_GCC_PEDANTIC_DEFAULT "OFF")
	ELSE(APPLE)
		SET(MRPT_BUILD_GCC_PEDANTIC_DEFAULT "ON")
	ENDIF(APPLE)

	SET( MRPT_BUILD_GCC_PEDANTIC ${MRPT_BUILD_GCC_PEDANTIC_DEFAULT} CACHE BOOL "Enable pedantic error detection (with GCC only)")

	# High level of warnings. 
	# The -Wno-long-long is required in 64bit systems when including sytem headers.
 	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CONFIGURE_CFLAGS} -Wall -Wno-long-long -Wno-write-strings")
 	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CONFIGURE_CFLAGS} -Wall -Wno-long-long -Wno-write-strings")

	IF(MRPT_BUILD_GCC_PEDANTIC)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
 		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pedantic")		
	ENDIF(MRPT_BUILD_GCC_PEDANTIC)

	# We need pthread's
	IF (UNIX)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
	ENDIF(UNIX)

	IF(MRPT_WARNINGS_ARE_ERRORS)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
	ENDIF(MRPT_WARNINGS_ARE_ERRORS)


	# Whole program optimization
	IF(MRPT_WHOLE_PROGRAM_OPTIMIZATION)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --combine")

		SET(MRPT_EXES_CXX_FLAGS "${MRPT_EXES_CXX_FLAGS} -fwhole-program --combine")
	ENDIF(MRPT_WHOLE_PROGRAM_OPTIMIZATION)


	# "-mtune=native" generates code optimized for the detected current processor.
	IF (CMAKE_MRPT_GCC_VERSION GREATER 41)
		SET( MRPT_OPTIMIZE_NATIVE ON CACHE BOOL "GCC optimizations for current processor (-mtune=native). Requires GCC 4.2+")
	ELSE (CMAKE_MRPT_GCC_VERSION GREATER 41)
		SET( MRPT_OPTIMIZE_NATIVE OFF CACHE BOOL "GCC optimizations for current processor (-mtune=native). Requires GCC 4.2+")
	ENDIF (CMAKE_MRPT_GCC_VERSION GREATER 41)

	IF(CMAKE_BUILD_TYPE STREQUAL "Debug")  # Not in debug!
		SET(MRPT_OPTIMIZE_NATIVE OFF)
	ENDIF(CMAKE_BUILD_TYPE STREQUAL "Debug")

	IF(CMAKE_MRPT_USE_DEB_POSTFIXS OR CMAKE_MRPT_IS_RPM_PACKAGE)
		# If we're building a Debian package, just DO NOT use -mtune=native
		SET(EXTRA_CPP_FLAGS ${CFLAGS})
	ELSE(CMAKE_MRPT_USE_DEB_POSTFIXS OR CMAKE_MRPT_IS_RPM_PACKAGE)
		IF(MRPT_OPTIMIZE_NATIVE AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
			SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -O3 -mtune=native ")
		ENDIF(MRPT_OPTIMIZE_NATIVE AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
	ENDIF(CMAKE_MRPT_USE_DEB_POSTFIXS OR CMAKE_MRPT_IS_RPM_PACKAGE)

	# "-ffast-math"
	SET( MRPT_OPTIMIZE_FFAST-MATH OFF CACHE BOOL "GCC optimization for floating math (-ffast-math).")
	IF(MRPT_OPTIMIZE_FFAST-MATH)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -ffast-math")
	ENDIF(MRPT_OPTIMIZE_FFAST-MATH)

	# Profiling?
	IF(MRPT_ENABLE_PROFILING)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -pg -g")
	ELSEIF(MRPT_ENABLE_PROFILING)
		# Remove unreferenced functions: function level linking
        # Remove unreferenced functions: function level linking
        if(NOT APPLE)
			SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections")
        endif(NOT APPLE)
	ENDIF(MRPT_ENABLE_PROFILING)

	# SSE2?
	IF (CMAKE_MRPT_HAS_SSE2)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -mfpmath=sse -msse2 -funroll-loops")
	ENDIF(CMAKE_MRPT_HAS_SSE2)


	# Parallel stdlibc++?
	IF(MRPT_ENABLE_LIBSTD_PARALLEL_MODE)
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -D_GLIBCXX_PARALLEL -fopenmp")
	ENDIF(MRPT_ENABLE_LIBSTD_PARALLEL_MODE)

	IF(CMAKE_BUILD_TYPE MATCHES "Debug")
		# This is to enable stack walker:
		SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -g")
		ADD_DEFINITIONS( -D_DEBUG)
		ADD_DEFINITIONS( -DDEBUG)
	ENDIF(CMAKE_BUILD_TYPE MATCHES "Debug")

	# Cross compiling Linux 64bits -> 32 bits?
	IF(UNIX)
		# Are we in a 64 bit Linux?
		IF(CMAKE_SIZEOF_VOID_P EQUAL 8)  # Size in bytes!
			SET( MRPT_CROSS_COMPILE_64_TO_32 OFF CACHE BOOL "Build 32 bit executables (Default=OFF, native 64 bit)")
			IF(MRPT_CROSS_COMPILE_64_TO_32)
				SET(EXTRA_CPP_FLAGS "${EXTRA_CPP_FLAGS} -m32")
				SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")
				SET(CMAKE_MRPT_64BIT_COMPILE_MODE "32 bit cross-compiling")

				SET(CMAKE_MRPT_WORD_SIZE 32)	# Fake wordsize
			ELSE(MRPT_CROSS_COMPILE_64_TO_32)
				SET(CMAKE_MRPT_64BIT_COMPILE_MODE "64 bit native")
			ENDIF(MRPT_CROSS_COMPILE_64_TO_32)
		ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)
	ENDIF(UNIX)


ENDIF(CMAKE_COMPILER_IS_GNUCXX)

# Even more warnings: "Scott Meyers' Effective C++ book"
IF(MRPT_EXTRA_WARNINGS)
	IF(CMAKE_COMPILER_IS_GNUCXX)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weffc++")  # -Wold-style-cast  -Woverloaded-virtual
	ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(MRPT_EXTRA_WARNINGS)



# Add user supplied extra options (optimization, etc...)
# ==========================================================
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CPP_FLAGS} ${USER_EXTRA_CPP_FLAGS}")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CPP_FLAGS} ${USER_EXTRA_CPP_FLAGS}")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${EXTRA_CPP_FLAGS} ${USER_EXTRA_CPP_FLAGS}")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${EXTRA_CPP_FLAGS} ${USER_EXTRA_CPP_FLAGS}")

# Some tricks for MSVC:
if(MSVC)
	STRING(REGEX REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
	SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GS-")
endif(MSVC)

IF(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
	# --as-needed: Avoid unnecesary libraries (.so dependencies):
	#SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
	#SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--as-needed")
ENDIF(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)


IF ("${CMAKE_CONFIGURE_LDFLAGS}")
	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_CONFIGURE_LDFLAGS}")
ENDIF ("${CMAKE_CONFIGURE_LDFLAGS}")

#MESSAGE(STATUS "Final CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
#MESSAGE(STATUS "Final CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
#MESSAGE(STATUS "Final CMAKE_SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
#MESSAGE(STATUS "Final MRPTLIB_LINKER_LIBS: ${MRPTLIB_LINKER_LIBS}")

# ----------------------------------------------------------------------------
#      					PROCESS SUBDIRECTORIES:
# ----------------------------------------------------------------------------
#MESSAGE(STATUS "CMAKE_CONFIGURATION_TYPES: ${CMAKE_CONFIGURATION_TYPES}")

# Save libs and executables in the same place
SET( LIBRARY_OUTPUT_PATH ${MRPT_BINARY_DIR}/lib CACHE PATH "Output directory for libraries" )
SET( EXECUTABLE_OUTPUT_PATH ${MRPT_BINARY_DIR}/bin CACHE PATH "Output directory for applications" )

#-----------------------------------
#  Build the hardware drivers?
#-----------------------------------
SET( BUILD_HWDRIVERS ON CACHE BOOL "Build hardware drivers (library apps/lib_hwdrivers)?.")
MARK_AS_ADVANCED(BUILD_HWDRIVERS)


#--------------------------------------------------------------
# If we are building the final step of the Debian package,
#  save each library files in the corresponding directories:
#--------------------------------------------------------------
IF(CMAKE_MRPT_USE_DEB_POSTFIXS)
	# Values when building a Debian package ---------------
	MESSAGE(STATUS "** mrpt cmake: Using Debian post-fix for install directories **")
	SET(libmrpt_dev_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/libmrpt-dev/usr/")
	SET(mrpt_apps_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/mrpt-apps/usr/")
	SET(mrpt_doc_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/mrpt-doc/usr/")
	SET(mrpt_pkgconfig_INSTALL_PREFIX "/usr")
ELSE(CMAKE_MRPT_USE_DEB_POSTFIXS)
	# Values under normal conditions -----------------------
	SET(libmrpt_dev_INSTALL_PREFIX "")
	SET(mrpt_apps_INSTALL_PREFIX "")
	SET(mrpt_doc_INSTALL_PREFIX "")
	SET(mrpt_pkgconfig_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
ENDIF(CMAKE_MRPT_USE_DEB_POSTFIXS)


# Remove /STACK:10000000 set by CMake. This value for stack size
# is very high, limiting the number of threads we can spawn.
# Default value used by Windows is 1MB which is good enough.
# By: Sahn Lam, @ CMake mailing list
STRING(REGEX REPLACE "/STACK:[0-9]+" "/STACK:1000000" CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
STRING(REGEX REPLACE "/STACK:[0-9]+" "/STACK:1000000" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")

# Auxiliary macros:
# ===============================
include(cmakemodules/FilterFileLists.cmake REQUIRED)
include(cmakemodules/MRPTPCHSupport.cmake REQUIRED)
include(cmakemodules/DeclareMRPTLib.cmake REQUIRED)
include(cmakemodules/DeclareAppDependencies.cmake REQUIRED)

# This will become a list with all libraries to be built, and their
#  dependencies stored in "mrpt-${name}_LIB_DEPS"
SET(ALL_MRPT_LIBS "" CACHE INTERNAL "")  # This emulates global vars

#-----------------------------------
# The third-party libraries
#-----------------------------------
add_subdirectory(otherlibs)

#-----------------------------------
# The MRPT C++ libraries:
#-----------------------------------
add_subdirectory(libs)

#-----------------------------------
# The examples
#-----------------------------------
include(cmakemodules/DefineExamples.cmake REQUIRED)

#-----------------------------------
# The applications:
#-----------------------------------
add_subdirectory(apps)

#-----------------------------------
# Documentation targets:
#-----------------------------------
add_subdirectory(doc)
IF(UNIX)
	add_subdirectory(man-pages)
ENDIF(UNIX)

# Add a "virtual" library, just for backward compatibility:
#  "mrpt-core", which just maps into a dependence on "mrpt-topography" + "mrpt-slam".
# ----------------------------------------------------------------------------
LIST(APPEND ALL_MRPT_LIBS mrpt-core)
get_property(_topo_DEP GLOBAL PROPERTY "mrpt-topography_LIB_DEPS")
get_property(_slam_DEP GLOBAL PROPERTY "mrpt-slam_LIB_DEPS")
set(_auxvar mrpt-topography mrpt-slam ${_topo_DEP} ${_slam_DEP})
list(REMOVE_DUPLICATES _auxvar)
set_property(GLOBAL PROPERTY "mrpt-core_LIB_DEPS" ${_auxvar})


# Create the code fragment: "DECLARE_LIBS_DEPS", for usage below while 
#  generating "MRPTConfig.cmake"
SET(DECLARE_LIBS_DEPS "")
FOREACH(_LIB ${ALL_MRPT_LIBS})
	get_property(_LIB_DEP GLOBAL PROPERTY "${_LIB}_LIB_DEPS")
	SET(DECLARE_LIBS_DEPS "${DECLARE_LIBS_DEPS} set_property(GLOBAL PROPERTY \"${_LIB}_LIB_DEPS\" \"${_LIB_DEP}\")\n")
ENDFOREACH(_LIB)


# ----------------------------------------------------------------------------
#   Generate the .pc file(s) for pkg-config
# ----------------------------------------------------------------------------
IF(UNIX)
	MESSAGE(STATUS "Generating libmrpt.pc file for pkg-config...")
	CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/pkgconfig/libmrpt.pc.in "${CMAKE_BINARY_DIR}/pkgconfig/libmrpt.pc" @ONLY)
ENDIF(UNIX)

# ----------------------------------------------------------------------------
#   Generate the MRPTConfig.cmake file
# ----------------------------------------------------------------------------
SET(THE_MRPT_SOURCE_DIR "${MRPT_SOURCE_DIR}")
SET(THE_MRPT_LIBS_INCL_DIR "${THE_MRPT_SOURCE_DIR}/libs")
SET(THE_CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}")
SET(THE_MRPT_CONFIG_FILE_INCLUDE_DIR "${MRPT_CONFIG_FILE_INCLUDE_DIR}")

CONFIGURE_FILE("${MRPT_SOURCE_DIR}/MRPTConfig.cmake.in"
               "${MRPT_BINARY_DIR}/MRPTConfig.cmake" @ONLY IMMEDIATE )

# ----------------------------------------------------------------------------
#   Generate the MRPTConfig.cmake file for unix
#      installation in CMAKE_INSTALL_PREFIX
# ----------------------------------------------------------------------------
IF(WIN32)
	SET(THE_MRPT_SOURCE_DIR "\${THIS_MRPT_CONFIG_PATH}")
	SET(THE_MRPT_LIBS_INCL_DIR "${THE_MRPT_SOURCE_DIR}/libs")
	SET(THE_CMAKE_BINARY_DIR "\${THIS_MRPT_CONFIG_PATH}")
	SET(THE_MRPT_CONFIG_FILE_INCLUDE_DIR "\${THIS_MRPT_CONFIG_PATH}/include/mrpt/mrpt-config/")
ELSE(WIN32)
	# Unix install. This .cmake file will end up in /usr/share/mrpt/MRPTConfig.cmake :
	IF (CMAKE_MRPT_USE_DEB_POSTFIXS)
		# We're building a .deb package: DESTDIR is NOT the final installation directory:
		SET(THE_MRPT_SOURCE_DIR "/usr")
		SET(THE_MRPT_LIBS_INCL_DIR "${THE_MRPT_SOURCE_DIR}/include/mrpt")
		SET(THE_CMAKE_BINARY_DIR "/usr")
		SET(THE_MRPT_CONFIG_FILE_INCLUDE_DIR "/usr/include/mrpt/mrpt-config/")
	ELSE(CMAKE_MRPT_USE_DEB_POSTFIXS)
		# Normal case: take the desired installation directory
		SET(THE_MRPT_SOURCE_DIR "${CMAKE_INSTALL_PREFIX}")
		SET(THE_MRPT_LIBS_INCL_DIR "${THE_MRPT_SOURCE_DIR}/include/mrpt")
		SET(THE_CMAKE_BINARY_DIR "${CMAKE_INSTALL_PREFIX}")
		SET(THE_MRPT_CONFIG_FILE_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include/mrpt/mrpt-config/")
	ENDIF(CMAKE_MRPT_USE_DEB_POSTFIXS)
ENDIF(WIN32)

CONFIGURE_FILE("${MRPT_SOURCE_DIR}/MRPTConfig.cmake.in"
               "${MRPT_BINARY_DIR}/unix-install/MRPTConfig.cmake" @ONLY IMMEDIATE )

# ----------------------------------------------------------------------------
#   Uninstall target, for "make uninstall"
# ----------------------------------------------------------------------------
CONFIGURE_FILE(
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
  IMMEDIATE @ONLY)

ADD_CUSTOM_TARGET(uninstall
  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")


# ----------------------------------------------------------------------------
#  Hide some variables to the user, just show the important variables:
# ----------------------------------------------------------------------------
MARK_AS_ADVANCED(FORCE
	CMAKE_BACKWARDS_COMPATIBILITY
	wxWidgets_CONFIGURATION
	wxWidgets_LIB_DIR
#	wxWidgets_ROOT_DIR
	wxWidgets_USE_REL_AND_DBG
	wxWidgets_wxrc_EXECUTABLE
)

# ----------------------------------------------------------------------------
#   An auxiliary function to show messages:
# ----------------------------------------------------------------------------
MACRO(SHOW_CONFIG_LINE MSG_TEXT VALUE_BOOL)
	IF(${VALUE_BOOL})
		SET(VAL_TEXT "Yes")
	ELSE(${VALUE_BOOL})
		SET(VAL_TEXT " No")
	ENDIF(${VALUE_BOOL})
	MESSAGE(STATUS " ${MSG_TEXT} : ${VAL_TEXT} ${ARGV2}")
ENDMACRO(SHOW_CONFIG_LINE)

MACRO(SHOW_CONFIG_LINE_SYSTEM MSG_TEXT VALUE_BOOL)
	IF(${VALUE_BOOL})
		IF(${VALUE_BOOL}_SYSTEM)
			SET(VAL_TEXT "Yes (System)")
		ELSE(${VALUE_BOOL}_SYSTEM)
			SET(VAL_TEXT "Yes (Built-in)")
		ENDIF(${VALUE_BOOL}_SYSTEM)
	ELSE(${VALUE_BOOL})
		SET(VAL_TEXT " No")
	ENDIF(${VALUE_BOOL})
	MESSAGE(STATUS " ${MSG_TEXT} : ${VAL_TEXT} ${ARGV2}")
ENDMACRO(SHOW_CONFIG_LINE_SYSTEM)


# ----------------------------------------------------------------------------
#   TESTS
# ----------------------------------------------------------------------------
SET( BUILD_TESTING ON CACHE BOOL "Build MRPT tests")
IF( BUILD_TESTING)
	add_subdirectory(tests)
ENDIF( BUILD_TESTING)



# ----------------------------------------------------------------------------
#   More installation commands:
# ----------------------------------------------------------------------------
IF(EXISTS "${MRPT_BINARY_DIR}/pkgconfig/libmrpt.pc")
	INSTALL(FILES "${MRPT_BINARY_DIR}/pkgconfig/libmrpt.pc" DESTINATION ${libmrpt_dev_INSTALL_PREFIX}lib${LIB_SUFFIX}/pkgconfig)
ENDIF(EXISTS "${MRPT_BINARY_DIR}/pkgconfig/libmrpt.pc")

# CMake will look for MRPTConfig.cmake at: /usr/share|lib/mrpt
IF(WIN32)
	INSTALL(FILES "${MRPT_BINARY_DIR}/unix-install/MRPTConfig.cmake" DESTINATION ./ )
ELSE(WIN32)
	INSTALL(FILES "${MRPT_BINARY_DIR}/unix-install/MRPTConfig.cmake" DESTINATION ${libmrpt_dev_INSTALL_PREFIX}share/mrpt )
ENDIF(WIN32)

# Docs, examples and the rest of files:
IF(WIN32)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/doc" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/cmakemodules" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/makefiles" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/man-pages" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/otherlibs" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/parse-files" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/pkgconfig" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/samples" DESTINATION ./  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share" DESTINATION ./  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/scripts" DESTINATION ./  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/swig" DESTINATION ./ PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/tests" DESTINATION ./  PATTERN ".svn" EXCLUDE)
	
	# Smart determination of the dependencies DLLs so they are also copied when installing:
	# ---------------------------------------------------------------------------------------
	# wxWidgets:
	IF (EXISTS "${wxWidgets_ROOT_DIR}/lib/vc_dll")
		FILE(GLOB_RECURSE EXTRA_DLLS "${wxWidgets_ROOT_DIR}/lib/vc_dll/*.dll")
		FOREACH(F ${EXTRA_DLLS})
			INSTALL(FILES "${F}" DESTINATION bin)
		ENDFOREACH(F)
	ENDIF (EXISTS "${wxWidgets_ROOT_DIR}/lib/vc_dll")
	
	# OpenCV:
	IF (EXISTS "${OpenCV_DIR}/bin/Release")
		FILE(GLOB_RECURSE EXTRA_DLLS "${OpenCV_DIR}/bin/*.dll")
		FOREACH(F ${EXTRA_DLLS})
			INSTALL(FILES "${F}" DESTINATION bin)
		ENDFOREACH(F)
	ENDIF (EXISTS "${OpenCV_DIR}/bin/Release")
	
	# ffmpeg:
	IF (EXISTS "${FFMPEG_WIN32_ROOT_DIR}/bin")
		FILE(GLOB_RECURSE EXTRA_DLLS "${FFMPEG_WIN32_ROOT_DIR}/bin/*.dll")
		FOREACH(F ${EXTRA_DLLS})
			INSTALL(FILES "${F}" DESTINATION bin)
		ENDFOREACH(F)
	ENDIF (EXISTS "${FFMPEG_WIN32_ROOT_DIR}/bin")	
	
	# Extra optional DLLs to be installed in the "bin" folder:
	file(TO_CMAKE_PATH "$ENV{MRPT_EXTRA_DLLS_TO_INSTALL}" MRPT_EXTRA_DLLS_TO_INSTALL)
	IF (NOT "${MRPT_EXTRA_DLLS_TO_INSTALL}" STREQUAL "")
		if (EXISTS "${MRPT_EXTRA_DLLS_TO_INSTALL}")
			FILE(STRINGS "${MRPT_EXTRA_DLLS_TO_INSTALL}" MRPT_EXTRA_DLLS_TO_INSTALL_FILES)
			FOREACH(XFIL ${MRPT_EXTRA_DLLS_TO_INSTALL_FILES})
				file(TO_CMAKE_PATH "${XFIL}" XFIL2)
				INSTALL(FILES "${XFIL2}" DESTINATION bin)
			ENDFOREACH(XFIL)
		endif (EXISTS "${MRPT_EXTRA_DLLS_TO_INSTALL}")
	ENDIF(NOT "${MRPT_EXTRA_DLLS_TO_INSTALL}" STREQUAL "")

	# My own debug DLLs:
	FILE(GLOB_RECURSE EXTRA_DLLS "${MRPT_BINARY_DIR}/bin/Debug/*.dll")
	FOREACH(F ${EXTRA_DLLS})
		INSTALL(FILES "${F}" DESTINATION bin)
	ENDFOREACH(F)
	FILE(GLOB_RECURSE EXTRA_LIBS "${MRPT_BINARY_DIR}/lib/Debug/*.lib")
	FOREACH(F ${EXTRA_LIBS})
		INSTALL(FILES "${F}" DESTINATION lib)
	ENDFOREACH(F)
	
ELSE(WIN32)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/doc/html" DESTINATION ${mrpt_doc_INSTALL_PREFIX}share/doc/mrpt-doc/  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/samples" DESTINATION ${mrpt_doc_INSTALL_PREFIX}share/doc/mrpt-doc/  PATTERN ".svn" EXCLUDE)
	INSTALL(FILES "${MRPT_SOURCE_DIR}/doc/mrpt_example1.tar.gz" DESTINATION ${mrpt_doc_INSTALL_PREFIX}share/doc/mrpt-doc/ )
	IF(EXISTS "${MRPT_SOURCE_DIR}/doc/mrpt-book.ps.gz")
		INSTALL(FILES "${MRPT_SOURCE_DIR}/doc/mrpt-book.ps.gz" DESTINATION ${mrpt_doc_INSTALL_PREFIX}share/doc/mrpt-doc/ )
	ENDIF(EXISTS "${MRPT_SOURCE_DIR}/doc/mrpt-book.ps.gz")
	
	# applications config files
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share/applications" DESTINATION ${mrpt_apps_INSTALL_PREFIX}share PATTERN ".svn" EXCLUDE)
	#INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share/menu" DESTINATION ${mrpt_apps_INSTALL_PREFIX}share  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share/mrpt" DESTINATION ${mrpt_apps_INSTALL_PREFIX}share  PATTERN ".svn" EXCLUDE)
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share/pixmaps" DESTINATION ${mrpt_apps_INSTALL_PREFIX}share  PATTERN ".svn" EXCLUDE)

 	# Mime types go to the mrpt-core package
	INSTALL(DIRECTORY "${MRPT_SOURCE_DIR}/share/mime" DESTINATION ${mrpt_apps_INSTALL_PREFIX}share  PATTERN ".svn" EXCLUDE)
ENDIF(WIN32)

# The headers of all the MRPT libs:
# (in win32 the /libs/* tree is install entirely, not only the headers):
IF (UNIX)
	FOREACH(_LIB ${ALL_MRPT_LIBS})
		STRING(REGEX REPLACE "mrpt-(.*)" "\\1" _LIB ${_LIB})
		SET(SRC_DIR "${MRPT_SOURCE_DIR}/libs/${_LIB}/include/")
		IF (EXISTS "${SRC_DIR}")  # This is mainly to avoid a crash with "mrpt-core", which is a "virtual" MRPT module.
			INSTALL(DIRECTORY "${SRC_DIR}" DESTINATION ${libmrpt_dev_INSTALL_PREFIX}include/mrpt/${_LIB}/include/  PATTERN ".svn" EXCLUDE)
		ENDIF (EXISTS "${SRC_DIR}")
	ENDFOREACH(_LIB)
ENDIF(UNIX)


# Config-dependent headers:
INSTALL(FILES "${MRPT_CONFIG_FILE_INCLUDE_DIR}/mrpt/config.h" DESTINATION ${libmrpt_dev_INSTALL_PREFIX}include/mrpt/mrpt-config/mrpt/ )
INSTALL(FILES "${MRPT_CONFIG_FILE_INCLUDE_DIR}/mrpt/version.h" DESTINATION ${libmrpt_dev_INSTALL_PREFIX}include/mrpt/mrpt-config/mrpt/ )


# ----------------------------------------------------------------------------
#   Sumary:
# ----------------------------------------------------------------------------
MESSAGE(STATUS "")

message(STATUS "Compiler:                  ${CMAKE_COMPILER}")
message(STATUS "  C++ flags (Release):       ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
message(STATUS "  C++ flags (Debug):         ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
message(STATUS "  Executable link flags (Release):    ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
message(STATUS "  Executable link flags (Debug):      ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
message(STATUS "  Lib link flags (Release):    ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
message(STATUS "  Lib link flags (Debug):      ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
MESSAGE(STATUS "")

MESSAGE(STATUS "List of MRPT libs/modules to be built (and dependencies):")
MESSAGE(STATUS "-----------------------------------------------------------------")
FOREACH(_LIB ${ALL_MRPT_LIBS})
	get_property(_LIB_DEP GLOBAL PROPERTY "${_LIB}_LIB_DEPS")
	MESSAGE(STATUS "  ${_LIB} : ${_LIB_DEP}")
ENDFOREACH(_LIB)
MESSAGE(STATUS "")

MESSAGE(STATUS "Resulting configuration for ${CMAKE_MRPT_COMPLETE_NAME}:")
MESSAGE(STATUS "-----------------------------------------------------------------")
SHOW_CONFIG_LINE("Will MRPT be built as a shared library? " CMAKE_MRPT_BUILD_SHARED_LIB_ONOFF)
SHOW_CONFIG_LINE("Additional checks even in Release       " CMAKE_MRPT_ALWAYS_CHECKS_DEBUG)
SHOW_CONFIG_LINE("Additional matrix checks                " CMAKE_MRPT_ALWAYS_CHECKS_DEBUG_MATRICES)
MESSAGE(STATUS  " Word size (32/64 bits)                   : ${CMAKE_MRPT_WORD_SIZE}")
IF(CMAKE_MRPT_64BIT_COMPILE_MODE)
	MESSAGE(STATUS   " 64 bit compilation mode                  : ${CMAKE_MRPT_64BIT_COMPILE_MODE}")
ENDIF(CMAKE_MRPT_64BIT_COMPILE_MODE)

SHOW_CONFIG_LINE("Is system big endian?                   " CMAKE_MRPT_IS_BIG_ENDIAN)
SHOW_CONFIG_LINE("Use MMX/SSE2?                           " CMAKE_MRPT_HAS_SSE2)
SHOW_CONFIG_LINE("Use OpenMP?                             " CMAKE_MRPT_HAS_OPENMP)

SHOW_CONFIG_LINE("Has Bumblebee stereo camera             " CMAKE_MRPT_HAS_BUMBLEBEE)
SHOW_CONFIG_LINE("Has wxWidgets incl. OpenGL classes      " CMAKE_MRPT_HAS_WXWIDGETS)
SHOW_CONFIG_LINE("Has OpenGL & GLUT:                      " CMAKE_MRPT_HAS_OPENGL_GLUT)
SHOW_CONFIG_LINE("Has xSENS MTi library (inertial sensor) " CMAKE_MRPT_HAS_xSENS)
SHOW_CONFIG_LINE("Has libdc1394-2 (FireWire capture)      " CMAKE_MRPT_HAS_LIBDC1394_2)
SHOW_CONFIG_LINE("Has SwissRanger 3/4000 3D camera        " CMAKE_MRPT_HAS_SWISSRANGE )



SHOW_CONFIG_LINE_SYSTEM("Has OpenCV (Image manipulation)         " CMAKE_MRPT_HAS_OPENCV "Version: ${MRPT_OPENCV_VERSION}")
SHOW_CONFIG_LINE("Has FabMap (optional for HMT-SLAM)      " CMAKE_MRPT_HAS_FABMAP )
SHOW_CONFIG_LINE_SYSTEM("Has ffmpeg libs (Video streaming)       " CMAKE_MRPT_HAS_FFMPEG "avcodec ${LIBAVCODEC_VERSION}, avutil ${LIBAVUTIL_VERSION}, avformat ${LIBAVFORMAT_VERSION}")
SHOW_CONFIG_LINE_SYSTEM("Has lib3ds (3DStudio scenes)            " CMAKE_MRPT_HAS_LIB3DS)
SHOW_CONFIG_LINE_SYSTEM("Has zlib (compression)                  " CMAKE_MRPT_HAS_ZLIB)
SHOW_CONFIG_LINE_SYSTEM("Has libjpeg (jpeg)                      " CMAKE_MRPT_HAS_JPEG)

IF(UNIX)
	SHOW_CONFIG_LINE_SYSTEM("Has libftdi (USB)                       " CMAKE_MRPT_HAS_FTDI)
ENDIF(UNIX)
MESSAGE(STATUS "")

MESSAGE(STATUS "  Install prefix:     ${CMAKE_INSTALL_PREFIX}")
MESSAGE(STATUS "  C++ config header : ${MRPT_CONFIG_FILE_INCLUDE_DIR}")
MESSAGE(STATUS "-----------------------------------------------------------------")

MESSAGE(STATUS "")

# Final warnings:
IF (NOT CMAKE_MRPT_HAS_OPENCV AND NOT DISABLE_OPENCV)
	MESSAGE(STATUS "**WARNING**: It's STRONGLY recommended to build MRPT with OpenCV support. To do so, set OpenCV_DIR to its CMake build dir.")
ENDIF(NOT CMAKE_MRPT_HAS_OPENCV AND NOT DISABLE_OPENCV)
