gtsam/wrap/cmake/MatlabWrap.cmake

if(GTWRAP_PYTHON_PACKAGE_DIR)
  # packaged
  set(GTWRAP_PACKAGE_DIR "${GTWRAP_PYTHON_PACKAGE_DIR}")
else()
  set(GTWRAP_PACKAGE_DIR ${CMAKE_CURRENT_LIST_DIR}/..)
endif()

# Macro which finds and configure Matlab before we do any wrapping.
macro(find_and_configure_matlab)
  find_package(
    Matlab
    COMPONENTS MEX_COMPILER
    REQUIRED)

  if(NOT Matlab_MEX_COMPILER)
    message(
      FATAL_ERROR
        "Cannot find MEX compiler binary. Please check your Matlab installation and ensure MEX in installed as well."
    )
  endif()

  if(WRAP_BUILD_TYPE_POSTFIXES)
      set(CURRENT_POSTFIX ${CMAKE_${CMAKE_BUILD_TYPE_UPPER}_POSTFIX})
  endif()

  # WRAP_MEX_BUILD_STATIC_MODULE is not for Windows - on Windows any static
  # are already compiled into the library by the linker
  if(WRAP_MEX_BUILD_STATIC_MODULE AND WIN32)
      message(FATAL_ERROR "WRAP_MEX_BUILD_STATIC_MODULE should not be set on Windows - the linker already automatically compiles in any dependent static libraries. To create a standalone toolbox pacakge, simply ensure that CMake finds the static versions of all dependent libraries (Boost, etc).")
  endif()

  set(MEX_COMMAND ${Matlab_MEX_COMPILER} CACHE PATH "Path to MATLAB MEX compiler")
  set(MATLAB_ROOT ${Matlab_ROOT_DIR} CACHE PATH "Path to MATLAB installation root (e.g. /usr/local/MATLAB/R2012a)")

  # Try to automatically configure mex path from provided custom `bin` path.
  if(WRAP_CUSTOM_MATLAB_PATH)
    set(matlab_bin_directory ${WRAP_CUSTOM_MATLAB_PATH})

    if(WIN32)
      set(mex_program_name "mex.bat")
    else()
      set(mex_program_name "mex")
    endif()

    # Run find_program explicitly putting $PATH after our predefined program
    # directories using 'ENV PATH' and 'NO_SYSTEM_ENVIRONMENT_PATH' - this prevents
    # finding the LaTeX mex program (totally unrelated to MATLAB Mex) when LaTeX is
    # on the system path.
    find_program(MEX_COMMAND ${mex_program_name}
      PATHS ${matlab_bin_directory} ENV PATH
      NO_DEFAULT_PATH)
    mark_as_advanced(FORCE MEX_COMMAND)
    # Now that we have mex, trace back to find the Matlab installation root
    get_filename_component(MEX_COMMAND "${MEX_COMMAND}" REALPATH)
    get_filename_component(mex_path "${MEX_COMMAND}" PATH)
    if(mex_path MATCHES ".*/win64$")
      get_filename_component(MATLAB_ROOT "${mex_path}/../.." ABSOLUTE)
    else()
      get_filename_component(MATLAB_ROOT "${mex_path}/.." ABSOLUTE)
    endif()
  endif()
endmacro()

# Consistent and user-friendly wrap function
function(matlab_wrap interfaceHeader moduleName linkLibraries
         extraIncludeDirs extraMexFlags ignore_classes)
  find_and_configure_matlab()
  wrap_and_install_library("${interfaceHeader}" "${moduleName}" "${linkLibraries}"
                           "${extraIncludeDirs}" "${extraMexFlags}"
                           "${ignore_classes}")
endfunction()

# Wrapping function.  Builds a mex module from the provided
# interfaceHeader. For example, for the interface header gtsam.h, this will
# build the wrap module 'gtsam'.
#
# Arguments:
#
# interfaceHeader:  The relative path to the wrapper interface definition file.
# moduleName:       The name of the wrapped module, e.g. gtsam
# linkLibraries:    Any *additional* libraries to link.  Your project library
# (e.g. `lba`), libraries it depends on, and any necessary MATLAB libraries will
# be linked automatically.  So normally, leave this empty.
# extraIncludeDirs: Any *additional* include paths required by dependent libraries that have not
# already been added by include_directories.  Again, normally, leave this empty.
# extraMexFlags:    Any *additional* flags to pass to the compiler when building
# the wrap code.  Normally, leave this empty.
# ignore_classes:  List of classes to ignore in the wrapping.
function(wrap_and_install_library interfaceHeader moduleName linkLibraries
         extraIncludeDirs extraMexFlags ignore_classes)
  wrap_library_internal("${interfaceHeader}" "${moduleName}" "${linkLibraries}"
                        "${extraIncludeDirs}" "${mexFlags}")
  install_wrapped_library_internal("${moduleName}")
endfunction()

# Internal function that wraps a library and compiles the wrapper
function(wrap_library_internal interfaceHeader moduleName linkLibraries extraIncludeDirs
         extraMexFlags)
  if(UNIX AND NOT APPLE)
    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
      set(mexModuleExt mexa64)
    else()
      set(mexModuleExt mexglx)
    endif()
  elseif(APPLE)
    set(mexModuleExt mexmaci64)
  elseif(MSVC)
    if(CMAKE_CL_64)
      set(mexModuleExt mexw64)
    else()
      set(mexModuleExt mexw32)
    endif()
  endif()

  # Wrap codegen interface usage: wrap interfacePath moduleName toolboxPath
  # headerPath interfacePath : *absolute* path to directory of module interface
  # file moduleName    : the name of the module, interface file must be called
  # moduleName.h toolboxPath : the directory in which to generate the wrappers
  # headerPath    : path to matlab.h

  # Extract module name from interface header file name
  get_filename_component(interfaceHeader "${interfaceHeader}" ABSOLUTE)
  get_filename_component(modulePath "${interfaceHeader}" PATH)

  # Paths for generated files
  set(generated_files_path "${PROJECT_BINARY_DIR}/wrap/${moduleName}")
  set(generated_cpp_file "${generated_files_path}/${moduleName}_wrapper.cpp")
  set(compiled_mex_modules_root "${PROJECT_BINARY_DIR}/wrap/${moduleName}_mex")

  message(STATUS "Building wrap module ${moduleName}")

  # Set matlab.h in project
  set(matlab_h_path "${CMAKE_SOURCE_DIR}")

  # If building a static mex module, add all cmake-linked libraries to the
  # explicit link libraries list so that the next block of code can unpack any
  # static libraries
  set(automaticDependencies "")
  foreach(lib ${module} ${linkLibraries})
    if(TARGET "${lib}")
      get_target_property(dependentLibraries ${lib} INTERFACE_LINK_LIBRARIES)
      # message("DEPENDENT LIBRARIES:  ${dependentLibraries}")
      if(dependentLibraries)
        list(APPEND automaticDependencies ${dependentLibraries})
      endif()
    endif()
  endforeach()

  # CHRIS: Temporary fix. On my system the get_target_property above returned
  # Not-found for gtsam module This needs to be fixed!!
  if(UNIX AND NOT APPLE)
    list(
      APPEND
      automaticDependencies
      ${Boost_SERIALIZATION_LIBRARY_RELEASE}
      ${Boost_FILESYSTEM_LIBRARY_RELEASE}
      ${Boost_SYSTEM_LIBRARY_RELEASE}
      ${Boost_THREAD_LIBRARY_RELEASE}
      ${Boost_DATE_TIME_LIBRARY_RELEASE})
    # Only present in Boost >= 1.48.0
    if(Boost_TIMER_LIBRARY_RELEASE)
      list(APPEND automaticDependencies ${Boost_TIMER_LIBRARY_RELEASE}
           ${Boost_CHRONO_LIBRARY_RELEASE})
      if(WRAP_MEX_BUILD_STATIC_MODULE)
        # list(APPEND automaticDependencies -Wl,--no-as-needed -lrt)
      endif()
    endif()
  endif()

  # message("AUTOMATIC DEPENDENCIES:  ${automaticDependencies}") CHRIS: End
  # temporary fix

  # Separate dependencies
  set(correctedOtherLibraries "")
  set(otherLibraryTargets "")
  set(otherLibraryNontargets "")
  set(otherSourcesAndObjects "")
  foreach(lib ${module} ${linkLibraries} ${automaticDependencies})
    if(TARGET "${lib}")
      if(WRAP_MEX_BUILD_STATIC_MODULE)
        get_target_property(target_sources ${lib} SOURCES)
        list(APPEND otherSourcesAndObjects ${target_sources})
      else()
        list(APPEND correctedOtherLibraries ${lib})
        list(APPEND otherLibraryTargets ${lib})
      endif()
    else()
      get_filename_component(file_extension "${lib}" EXT)
      get_filename_component(lib_name "${lib}" NAME_WE)
      if(file_extension STREQUAL ".a" AND WRAP_MEX_BUILD_STATIC_MODULE)
        # For building a static MEX module, unpack the static library and
        # compile its object files into our module
        file(MAKE_DIRECTORY "${generated_files_path}/${lib_name}_objects")
        execute_process(
          COMMAND ar -x "${lib}"
          WORKING_DIRECTORY "${generated_files_path}/${lib_name}_objects"
          RESULT_VARIABLE ar_result)
        if(NOT ar_result EQUAL 0)
          message(FATAL_ERROR "Failed extracting ${lib}")
        endif()

        # Get list of object files
        execute_process(
          COMMAND ar -t "${lib}"
          OUTPUT_VARIABLE object_files
          RESULT_VARIABLE ar_result)
        if(NOT ar_result EQUAL 0)
          message(FATAL_ERROR "Failed listing ${lib}")
        endif()

        # Add directory to object files
        string(REPLACE "\n" ";" object_files_list "${object_files}")
        foreach(object_file ${object_files_list})
          get_filename_component(file_extension "${object_file}" EXT)
          if(file_extension STREQUAL ".o")
            list(APPEND otherSourcesAndObjects
                 "${generated_files_path}/${lib_name}_objects/${object_file}")
          endif()
        endforeach()
      else()
        list(APPEND correctedOtherLibraries ${lib})
        list(APPEND otherLibraryNontargets ${lib})
      endif()
    endif()
  endforeach()

  # Check libraries for conflicting versions built-in to MATLAB
  set(dependentLibraries "")
  if(NOT "${otherLibraryTargets}" STREQUAL "")
    foreach(target ${otherLibraryTargets})
      get_target_property(dependentLibrariesOne ${target}
                          INTERFACE_LINK_LIBRARIES)
      list(APPEND dependentLibraries ${dependentLibrariesOne})
    endforeach()
  endif()
  list(APPEND dependentLibraries ${otherLibraryNontargets})
  check_conflicting_libraries_internal("${dependentLibraries}")

  # Set up generation of module source file
  file(MAKE_DIRECTORY "${generated_files_path}")

  find_package(PythonInterp ${WRAP_PYTHON_VERSION} EXACT)
  find_package(PythonLibs ${WRAP_PYTHON_VERSION} EXACT)

  # Set the path separator for PYTHONPATH
  if(UNIX)
    set(GTWRAP_PATH_SEPARATOR ":")
  else()
    set(GTWRAP_PATH_SEPARATOR ";")
  endif()

  add_custom_command(
    OUTPUT ${generated_cpp_file}
    DEPENDS ${interfaceHeader} ${module_library_target} ${otherLibraryTargets}
            ${otherSourcesAndObjects}
    COMMAND
      ${CMAKE_COMMAND} -E env
      "PYTHONPATH=${GTWRAP_PACKAGE_DIR}${GTWRAP_PATH_SEPARATOR}$ENV{PYTHONPATH}"
      ${PYTHON_EXECUTABLE} ${MATLAB_WRAP_SCRIPT} --src "${interfaceHeader}"
      --module_name ${moduleName} --out ${generated_files_path}
      --top_module_namespaces ${moduleName} --ignore ${ignore_classes}
    VERBATIM
    WORKING_DIRECTORY ${generated_files_path})

  # Set up building of mex module
  string(REPLACE ";" " " extraMexFlagsSpaced "${extraMexFlags}")
  string(REPLACE ";" " " mexFlagsSpaced "${WRAP_BUILD_MEX_BINARY_FLAGS}")
  add_library(
    ${moduleName}_matlab_wrapper MODULE
    ${generated_cpp_file} ${interfaceHeader} ${otherSourcesAndObjects})
  target_link_libraries(${moduleName}_matlab_wrapper ${correctedOtherLibraries})
  target_link_libraries(${moduleName}_matlab_wrapper ${moduleName})
  set_target_properties(
    ${moduleName}_matlab_wrapper
    PROPERTIES OUTPUT_NAME "${moduleName}_wrapper"
               PREFIX ""
               SUFFIX ".${mexModuleExt}"
               LIBRARY_OUTPUT_DIRECTORY "${compiled_mex_modules_root}"
               ARCHIVE_OUTPUT_DIRECTORY "${compiled_mex_modules_root}"
               RUNTIME_OUTPUT_DIRECTORY "${compiled_mex_modules_root}"
               CLEAN_DIRECT_OUTPUT 1)
  set_property(
    TARGET ${moduleName}_matlab_wrapper
    APPEND_STRING
    PROPERTY
      COMPILE_FLAGS
      " ${extraMexFlagsSpaced} ${mexFlagsSpaced} \"-I${MATLAB_ROOT}/extern/include\" -DMATLAB_MEX_FILE -DMX_COMPAT_32"
  )
  set_property(
    TARGET ${moduleName}_matlab_wrapper
    APPEND
    PROPERTY INCLUDE_DIRECTORIES ${extraIncludeDirs})
  # Disable build type postfixes for the mex module - we install in different
  # directories for each build type instead
  foreach(build_type ${CMAKE_CONFIGURATION_TYPES})
    string(TOUPPER "${build_type}" build_type_upper)
    set_target_properties(${moduleName}_matlab_wrapper
                          PROPERTIES ${build_type_upper}_POSTFIX "")
  endforeach()
  # Set up platform-specific flags
  if(MSVC)
    if(CMAKE_CL_64)
      set(mxLibPath "${MATLAB_ROOT}/extern/lib/win64/microsoft")
    else()
      set(mxLibPath "${MATLAB_ROOT}/extern/lib/win32/microsoft")
    endif()
    target_link_libraries(
      ${moduleName}_matlab_wrapper "${mxLibPath}/libmex.lib"
      "${mxLibPath}/libmx.lib" "${mxLibPath}/libmat.lib")
    set_target_properties(${moduleName}_matlab_wrapper
                          PROPERTIES LINK_FLAGS "/export:mexFunction")
    set_property(
      SOURCE "${generated_cpp_file}"
      APPEND
      PROPERTY COMPILE_FLAGS "/bigobj")
  elseif(APPLE)
    set(mxLibPath "${MATLAB_ROOT}/bin/maci64")
    target_link_libraries(
      ${moduleName}_matlab_wrapper "${mxLibPath}/libmex.dylib"
      "${mxLibPath}/libmx.dylib" "${mxLibPath}/libmat.dylib")
  endif()

  # Hacking around output issue with custom command Deletes generated build
  # folder
  add_custom_target(
    wrap_${moduleName}_matlab_distclean
    COMMAND cmake -E remove_directory ${generated_files_path}
    COMMAND cmake -E remove_directory ${compiled_mex_modules_root})
endfunction()

# Internal function that installs a wrap toolbox
function(install_wrapped_library_internal interfaceHeader)
  get_filename_component(module "${interfaceHeader}" NAME_WE)
  set(generated_files_path "${PROJECT_BINARY_DIR}/wrap/${module}")

  # NOTE: only installs .m and mex binary files (not .cpp) - the trailing slash
  # on the directory name here prevents creating the top-level module name
  # directory in the destination.
  message(STATUS "Installing Matlab Toolbox to ${WRAP_TOOLBOX_INSTALL_PATH}")
  if(WRAP_BUILD_TYPE_POSTFIXES)
    foreach(build_type ${CMAKE_CONFIGURATION_TYPES})
      string(TOUPPER "${build_type}" build_type_upper)
      if(${build_type_upper} STREQUAL "RELEASE")
        set(build_type_tag "") # Don't create release mode tag on installed
                               # directory
      else()
        set(build_type_tag "${build_type}")
      endif()
      # Split up filename to strip trailing '/' in WRAP_TOOLBOX_INSTALL_PATH if
      # there is one
      get_filename_component(location "${WRAP_TOOLBOX_INSTALL_PATH}" PATH)
      get_filename_component(name "${WRAP_TOOLBOX_INSTALL_PATH}" NAME)
      install(
        DIRECTORY "${generated_files_path}/"
        DESTINATION "${location}/${name}${build_type_tag}"
        CONFIGURATIONS "${build_type}"
        FILES_MATCHING
        PATTERN "*.m")
      install(
        TARGETS ${moduleName}_matlab_wrapper
        LIBRARY DESTINATION "${location}/${name}${build_type_tag}"
                CONFIGURATIONS "${build_type}"
        RUNTIME DESTINATION "${location}/${name}${build_type_tag}"
                CONFIGURATIONS "${build_type}")
    endforeach()
  else()
    install(
      DIRECTORY "${generated_files_path}/"
      DESTINATION ${WRAP_TOOLBOX_INSTALL_PATH}
      FILES_MATCHING
      PATTERN "*.m")
    install(
      TARGETS ${moduleName}_matlab_wrapper
      LIBRARY DESTINATION ${WRAP_TOOLBOX_INSTALL_PATH}
      RUNTIME DESTINATION ${WRAP_TOOLBOX_INSTALL_PATH})
  endif()
endfunction()

# Internal function to check for libraries installed with MATLAB that may
# conflict and prints a warning to move them if problems occur.
function(check_conflicting_libraries_internal libraries)
  if(UNIX)
    # Set path for matlab's built-in libraries
    if(APPLE)
      set(mxLibPath "${MATLAB_ROOT}/bin/maci64")
    else()
      if(CMAKE_CL_64)
        set(mxLibPath "${MATLAB_ROOT}/bin/glnxa64")
      else()
        set(mxLibPath "${MATLAB_ROOT}/bin/glnx86")
      endif()
    endif()

    # List matlab's built-in libraries
    file(
      GLOB matlabLibs
      RELATIVE "${mxLibPath}"
      "${mxLibPath}/lib*")

    # Convert to base names
    set(matlabLibNames "")
    foreach(lib ${matlabLibs})
      get_filename_component(libName "${lib}" NAME_WE)
      list(APPEND matlabLibNames "${libName}")
    endforeach()

    # Get names of link libraries
    set(linkLibNames "")
    foreach(lib ${libraries})
      string(FIND "${lib}" "/" slashPos)
      if(NOT slashPos EQUAL -1)
        # If the name is a path, just get the library name
        get_filename_component(libName "${lib}" NAME_WE)
        list(APPEND linkLibNames "${libName}")
      else()
        # It's not a path, so see if it looks like a filename
        get_filename_component(ext "${lib}" EXT)
        if(NOT "${ext}" STREQUAL "")
          # It's a filename, so get the base name
          get_filename_component(libName "${lib}" NAME_WE)
          list(APPEND linkLibNames "${libName}")
        else()
          # It's not a filename so it must be a short name, add the "lib" prefix
          list(APPEND linkLibNames "lib${lib}")
        endif()
      endif()
    endforeach()

    # Remove duplicates
    list(REMOVE_DUPLICATES linkLibNames)

    set(conflictingLibs "")
    foreach(lib ${linkLibNames})
      list(FIND matlabLibNames "${lib}" libPos)
      if(NOT libPos EQUAL -1)
        if(NOT conflictingLibs STREQUAL "")
          set(conflictingLibs "${conflictingLibs}, ")
        endif()
        set(conflictingLibs "${conflictingLibs}${lib}")
      endif()
    endforeach()

    if(NOT "${conflictingLibs}" STREQUAL "")
      message(
        WARNING
          "The project links to the libraries [ ${conflictingLibs} ] on your system, but "
          "MATLAB is distributed with its own versions of these libraries which may conflict. "
          "If you get strange errors or crashes with the MATLAB wrapper, move these "
          "libraries out of MATLAB's built-in library directory, which is ${mxLibPath} on "
          "your system. MATLAB will usually still work with these libraries moved away, but "
          "if not, you'll have to compile the static MATLAB wrapper module."
      )
    endif()
  endif()
endfunction()

# Helper function to install MATLAB scripts and handle multiple build types
# where the scripts should be installed to all build type toolboxes
function(install_matlab_scripts source_directory patterns)
  set(patterns_args "")
  set(exclude_patterns "")

  foreach(pattern ${patterns})
    list(APPEND patterns_args PATTERN "${pattern}")
  endforeach()
  if(WRAP_BUILD_TYPE_POSTFIXES)
    foreach(build_type ${CMAKE_CONFIGURATION_TYPES})
      string(TOUPPER "${build_type}" build_type_upper)
      if(${build_type_upper} STREQUAL "RELEASE")
        set(build_type_tag "") # Don't create release mode tag on installed
                               # directory
      else()
        set(build_type_tag "${build_type}")
      endif()
      # Split up filename to strip trailing '/' in WRAP_TOOLBOX_INSTALL_PATH if
      # there is one
      get_filename_component(location "${WRAP_TOOLBOX_INSTALL_PATH}" PATH)
      get_filename_component(name "${WRAP_TOOLBOX_INSTALL_PATH}" NAME)
      install(
        DIRECTORY "${source_directory}"
        DESTINATION "${location}/${name}${build_type_tag}"
        CONFIGURATIONS "${build_type}"
        FILES_MATCHING ${patterns_args}
        PATTERN "${exclude_patterns}" EXCLUDE)
    endforeach()
  else()
    install(
      DIRECTORY "${source_directory}"
      DESTINATION "${WRAP_TOOLBOX_INSTALL_PATH}"
      FILES_MATCHING ${patterns_args}
      PATTERN "${exclude_patterns}" EXCLUDE)
  endif()

endfunction()